@interactors/core 0.4.0 → 1.0.0-effection.0

package/src/format.ts

@@ -0,0 +1,58 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Match } from "./match";
+import { InteractorOptions } from "./specification";
+
+export interface TableOptions {
+  headers: string[];
+  rows: string[][];
+}
+
+const MAX_COLUMN_WIDTH = 40
+
+function formatValue(value: string, width: number) {
+  if(value.length > width) {
+    return value.slice(0, width - 1) + '…';
+  } else {
+    return value.padEnd(width);
+  }
+}
+
+export function formatTable(options: TableOptions): string {
+  let columnWidths = options.headers.map((h, index) => {
+    return Math.min(MAX_COLUMN_WIDTH, Math.max(h.length, ...options.rows.map((r) => r[index].length)));
+  });
+
+  let formatRow = (cells: string[]) => {
+    return '┃ ' + cells.map((c, index) => formatValue(c, columnWidths[index])).join(' ┃ ') + ' ┃';
+  }
+
+  let spacerRow = () => {
+    return '┣━' + columnWidths.map((w) => "━".repeat(w)).join('━╋━') + '━┫';
+  }
+
+  return [
+    formatRow(options.headers),
+    spacerRow(),
+    ...options.rows.map((row) => formatRow(row))
+  ].join('\n');
+}
+
+function ownDescription(options: InteractorOptions<any, any, any>): string {
+  if(options.locator) {
+    return `${options.name} ${options.locator.description} ${options.filter.description}`.trim();
+  } else {
+    return `${options.name} ${options.filter.description}`.trim();
+  }
+}
+
+export function formatDescription(options: InteractorOptions<any, any, any>): string {
+  let ancestorsAndSelf: InteractorOptions<any, any, any>[] = options.ancestors.concat(options);
+  return ancestorsAndSelf.reverse().map(ownDescription).join(' within ');
+}
+
+export function formatMatchesTable(interactor: InteractorOptions<any, any, any>, matches: Match<Element, any>[]): string {
+  return formatTable({
+    headers: interactor.locator ? [interactor.name, ...interactor.filter.asTableHeader()] : interactor.filter.asTableHeader(),
+    rows: matches.slice().sort((a, b) => b.sortWeight - a.sortWeight).map((m) => m.asTableRow()),
+  })
+}

package/src/index.ts

@@ -1,5 +1,5 @@
-export { Interactor, InteractorConstructor, InteractorSpecification } from './specification';
-export { Interaction, ReadonlyInteraction, isInteraction } from './interaction';
+export { Interactor, InteractorConstructor, InteractorSpecification, EmptyObject, FilterMethods, ActionMethods } from './specification';
+export { Interaction, ActionInteraction, AssertionInteraction, isInteraction } from './interaction';
 export { createInteractor } from './create-interactor';
 export { createInspector } from './inspector'
 export { isVisible } from 'element-is-visible';
@@ -14,3 +14,5 @@ export { some } from './matchers/some';
 export { every } from './matchers/every';
 
 export { click } from './element/click';
+export { MergeObjects } from './merge-objects'
+export { MaybeMatcher } from './matcher'

package/src/inspector.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { findElements, unsafeSyncResolveParent, instantiateInteractor } from "./constructor";
+import { instantiateInteractor } from "./constructor";
+import { findElements, unsafeSyncResolveParent } from './resolvers'
 import { Interactor, Filters, InteractorConstructor, FilterParams } from "./specification";
 
 type GetElement<I extends InteractorConstructor<any, any, any, any>> = I extends InteractorConstructor<infer E, any, any, any> ? E : never

package/src/interaction.ts

@@ -1,9 +1,12 @@
-import { globals } from '@interactors/globals';
-import type { FilterObject } from './specification';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Operation, Task, run, Symbol } from '@effection/core';
+import { InteractionOptions as SerializedInteractionOptions, globals, InteractionType } from '@interactors/globals';
+import type { Interactor, FilterObject, FilterFn, FilterParams } from './specification';
+import { serializeInteractionOptions } from './serialize';
 
-const interactionSymbol = Symbol.for('interaction');
+const interactionSymbol: unique symbol = Symbol.for('interaction') as any;
 
-export function isInteraction(x: unknown): x is Interaction<unknown> {
+export function isInteraction(x: unknown): x is Interaction<Element, unknown> {
   return typeof x === 'object' && x != null && interactionSymbol in x
 }
 
@@ -18,17 +21,38 @@ export function isInteraction(x: unknown): x is Interaction<unknown> {
  *
  * @typeParam T the return value of the promise that this interaction evaluates to.
  */
-export interface Interaction<T> extends Promise<T> {
+export interface Interaction<E extends Element, T = void> extends Promise<T> {
+  type: InteractionType;
+
+  interactor: Interactor<E, any>;
+  run: (interactor: Interactor<E, any>) => Operation<T>;
   /**
    * Return a description of the interaction
    */
   description: string;
+  /**
+   * Return a code representation of the interaction
+   */
+  code: () => string;
+  /**
+   * Return a serialized options of the interaction
+   */
+  options: SerializedInteractionOptions;
   /**
    * Perform the interaction
    */
-  action: () => Promise<T>;
+  action: () => Task<T>;
+
+  check?: () => Task<T>;
+
+  halt: () => Promise<void>;
 
-  [interactionSymbol]: true
+  [interactionSymbol]: true;
+}
+
+export interface ActionInteraction<E extends Element, T = void> extends Interaction<E, T> {
+  type: "action";
+  check: undefined;
 }
 
 /**
@@ -36,47 +60,83 @@ export interface Interaction<T> extends Promise<T> {
  *
  * @typeParam T the return value of the promise that this interaction evaluates to.
  */
-export interface ReadonlyInteraction<T> extends Interaction<T> {
+export interface AssertionInteraction<E extends Element, T = void> extends Interaction<E, T> {
+  type: "assertion";
   /**
    * Perform the check
    */
-  check: () => Promise<T>;
+  check: () => Task<T>;
+}
+
+export type InteractionOptions<E extends Element, T> = {
+  name: string;
+  description: string;
+  filters?: FilterParams<any, any>;
+  args?: unknown[];
+  interactor: Interactor<E, any>;
+  run: (interactor: Interactor<E, any>) => Operation<T>;
 }
 
-function createInteraction<T>(description: string, action: () => Promise<T>): Interaction<T> {
-  let promise: Promise<T>;
-  return {
-    description,
+export function createInteraction<E extends Element, T>(type: 'action', options: InteractionOptions<E, T>): ActionInteraction<E, T>
+export function createInteraction<E extends Element, T>(type: 'assertion', options: InteractionOptions<E, T>): AssertionInteraction<E, T>
+export function createInteraction<E extends Element, T, Q>(type: 'action', options: InteractionOptions<E, T>, apply: FilterFn<Q, Element>): ActionInteraction<E, T> & FilterObject<Q, Element>
+export function createInteraction<E extends Element, T, Q>(type: 'assertion', options: InteractionOptions<E, T>, apply: FilterFn<Q, Element>): AssertionInteraction<E, T> & FilterObject<Q, Element>
+export function createInteraction<E extends Element, T, Q>(type: InteractionType, options: InteractionOptions<E, T>, apply?: FilterFn<Q, Element>): Interaction<E, T> & Operation<T> {
+  let task: Task<T>;
+
+  function operation(): Operation<T> {
+    let run = () => options.run(options.interactor);
+    let operation = globals.wrapInteraction
+      ? globals.wrapInteraction(interaction, async () => run)
+      : globals.wrapAction(interaction.description, async () => run, type)
+
+    return function* () {
+      // NOTE: If effection gets Promise it will fulfill and treat the result as ended value
+      // NOTE: Sometimes original interaction function might be wrapped multiple times into async function
+      // NOTE: That means effection returns the original interaction function from a wrapped one instead of executing it
+      // NOTE: We `yield` operation until we get the `run` function which returns a generator
+      // NOTE: Then we yield it and return a result
+      while (operation != run) {
+        operation = yield operation
+      }
+      return yield operation;
+    } as Operation<T>;
+  };
+
+  function action(): Task<T> {
+    if(!task) {
+      task = run(operation);
+    }
+    return task;
+  };
+
+  let serializedOptions = serializeInteractionOptions(type, options)
+  let interaction: Interaction<E, T> & Operation<T> = {
+    type,
+    options: serializedOptions,
+    description: options.description,
+    interactor: options.interactor,
+    run: options.run,
     action,
+    check: type === 'assertion' ? action : undefined,
+    code: () => serializedOptions.code(),
+    halt: () => action().halt(),
     [interactionSymbol]: true,
-    [Symbol.toStringTag]: `[interaction ${description}]`,
+    [Symbol.toStringTag]: `[interaction ${options.description}]`,
+    [Symbol.operation]: operation,
     then(onFulfill, onReject) {
-      if(!promise) { promise = this.action(); }
-      return promise.then(onFulfill, onReject);
+      return action().then(onFulfill, onReject);
     },
     catch(onReject) {
-      if(!promise) { promise = this.action(); }
-      return promise.catch(onReject);
+      return action().catch(onReject);
     },
     finally(handler) {
-      if(!promise) { promise = this.action(); }
-      return promise.finally(handler);
+      return action().finally(handler);
     }
   }
-}
-
-export function interaction<T>(description: string, action: () => Promise<T>): Interaction<T> {
-  return createInteraction(description, globals.wrapAction(description, action, 'interaction'))
-}
-
-export function check<T>(description: string, check: () => Promise<T>): ReadonlyInteraction<T> {
-  return { check() { return this.action() }, ...createInteraction(description, globals.wrapAction(description, check, 'check')) };
-}
-
-export function interactionFilter<T, Q>(description: string, action: () => Promise<T>, filter: (element: Element) => Q): Interaction<T> & FilterObject<Q, Element> {
-  return { apply: filter, ...interaction(description, action) };
-}
-
-export function checkFilter<T, Q>(description: string, action: () => Promise<T>, filter: (element: Element) => Q): ReadonlyInteraction<T> & FilterObject<Q, Element> {
-  return { apply: filter , ...check(description, action) };
+  if (apply) {
+    return Object.assign(interaction, { apply });
+  } else {
+    return interaction;
+  }
 }

package/src/match.ts

@@ -9,7 +9,6 @@ const check = (value: unknown): string => value ? "✓" : "⨯";
 export class Match<E extends Element, F extends Filters<E>> {
   public matchLocator?: MatchLocator<E>;
   public matchFilter: MatchFilter<E, F>;
-  public matches: boolean;
 
   constructor(
     public element: E,
@@ -18,7 +17,10 @@ export class Match<E extends Element, F extends Filters<E>> {
   ) {
     this.matchLocator = locator && new MatchLocator(element, locator);
     this.matchFilter = new MatchFilter(element, filterSet);
-    this.matches = (this.matchLocator ? this.matchLocator.matches : true) && this.matchFilter.matches;
+  }
+
+  get matches(): boolean {
+    return (this.matchLocator ? this.matchLocator.matches : true) && this.matchFilter.matches;
   }
 
   asTableHeader(name: string): string[] {
@@ -51,7 +53,6 @@ export class Match<E extends Element, F extends Filters<E>> {
 }
 
 export class MatchLocator<E extends Element> {
-  public matches: boolean;
   public expected: MaybeMatcher<string> | null;
   public actual: string | null;
 
@@ -61,7 +62,10 @@ export class MatchLocator<E extends Element> {
   ) {
     this.expected = locator.value;
     this.actual = locator.apply(element);
-    this.matches = applyMatcher(this.expected, this.actual);
+  }
+
+  get matches(): boolean {
+    return applyMatcher(this.expected, this.actual)
   }
 
   formatActual(): string {
@@ -78,7 +82,6 @@ export class MatchLocator<E extends Element> {
 }
 
 export class MatchFilter<E extends Element, F extends Filters<E>> {
-  public matches: boolean;
   public items: MatchFilterItem<unknown, E, F>[];
 
   constructor(
@@ -88,7 +91,10 @@ export class MatchFilter<E extends Element, F extends Filters<E>> {
     this.items = Object.entries(filter.all).map(([key, expected]) => {
       return new MatchFilterItem(element, filter, key, expected)
     });
-    this.matches = this.items.every((match) => match.matches)
+  }
+
+  get matches(): boolean {
+    return this.items.every((match) => match.matches)
   }
 
   asTableRow(): string[] {
@@ -114,23 +120,25 @@ export function applyFilter<T>(definition: FilterDefinition<T, any>, element: El
 }
 
 export class MatchFilterItem<T, E extends Element, F extends Filters<E>> {
-  public actual: T;
-  public matches: boolean;
-
   constructor(
     public element: E,
     public filter: FilterSet<E, F>,
     public key: string,
     public expected: MaybeMatcher<T>,
-  ) {
-    if(this.filter.specification.filters && this.filter.specification.filters[this.key]) {
+  ) {}
+
+  get matches(): boolean {
+    return applyMatcher(this.expected, this.actual);
+  }
+
+  get actual(): T {
+    if (this.filter.specification.filters && this.filter.specification.filters[this.key]) {
       let definition = this.filter.specification.filters[this.key];
-      if(typeof(definition) === 'function') {
-        this.actual = definition(this.element) as T;
+      if (typeof definition === 'function') {
+        return definition(this.element) as T;
       } else {
-        this.actual = definition.apply(this.element) as T;
+        return definition.apply(this.element) as T;
       }
-      this.matches = applyMatcher(this.expected, this.actual);
     } else {
       throw new Error(`interactor does not define a filter named ${JSON.stringify(this.key)}`);
     }

package/src/matcher.ts

@@ -3,6 +3,7 @@ import isEqual from 'lodash.isequal';
 export interface Matcher<T> {
   match(actual: T): boolean;
   description(): string;
+  code?(): string;
 }
 
 export type MaybeMatcher<T> = Matcher<T> | T;
@@ -26,3 +27,13 @@ export function applyMatcher<T>(value: MaybeMatcher<T>, actual: T): boolean {
     return isEqual(value, actual);
   }
 }
+
+export function matcherCode<T>(value: MaybeMatcher<T>): string {
+  if (isMatcher(value) && value.code) {
+    return value.code();
+  } else if (value instanceof RegExp) {
+    return value.toString();
+  } else {
+    return JSON.stringify(value);
+  }
+}

package/src/matchers/and.ts

@@ -1,4 +1,4 @@
-import { Matcher, MaybeMatcher, matcherDescription, applyMatcher } from '../matcher';
+import { Matcher, MaybeMatcher, matcherDescription, applyMatcher, matcherCode } from '../matcher';
 
 export function and<T>(...args: MaybeMatcher<T>[]): Matcher<T> {
   return {
@@ -8,5 +8,8 @@ export function and<T>(...args: MaybeMatcher<T>[]): Matcher<T> {
     description(): string {
       return args.map(matcherDescription).join(' and ');
     },
+    code(): string {
+      return `and(${args.map(arg => matcherCode(arg)).join(', ')})`
+    }
   }
 }

package/src/matchers/every.ts

@@ -1,4 +1,4 @@
-import { Matcher, MaybeMatcher, applyMatcher, matcherDescription } from '../matcher';
+import { Matcher, MaybeMatcher, applyMatcher, matcherDescription, matcherCode } from '../matcher';
 
 export function every<T>(expected: MaybeMatcher<T>): Matcher<Iterable<T>> {
   return {
@@ -8,5 +8,8 @@ export function every<T>(expected: MaybeMatcher<T>): Matcher<Iterable<T>> {
     description(): string {
       return `every item ${matcherDescription(expected)}`;
     },
+    code(): string {
+      return `every(${matcherCode(expected)})`
+    }
   }
 }

package/src/matchers/including.ts

@@ -1,4 +1,4 @@
-import { Matcher } from '../matcher';
+import { Matcher, matcherCode} from '../matcher';
 
 export function including(subString: string): Matcher<string> {
   return {
@@ -8,5 +8,8 @@ export function including(subString: string): Matcher<string> {
     description(): string {
       return `including ${JSON.stringify(subString)}`;
     },
+    code(): string {
+      return `including(${matcherCode(subString)})`
+    }
   }
 }

package/src/matchers/matching.ts

@@ -1,4 +1,4 @@
-import { Matcher } from '../matcher';
+import { Matcher, matcherCode } from '../matcher';
 
 export function matching(regexp: RegExp): Matcher<string> {
   return {
@@ -8,5 +8,8 @@ export function matching(regexp: RegExp): Matcher<string> {
     description(): string {
       return `matching ${regexp}`;
     },
+    code(): string {
+      return `matching(${matcherCode(regexp)})`
+    }
   }
 }

package/src/matchers/not.ts

@@ -1,4 +1,4 @@
-import { Matcher, MaybeMatcher, matcherDescription, applyMatcher } from '../matcher';
+import { Matcher, MaybeMatcher, matcherDescription, applyMatcher, matcherCode } from '../matcher';
 
 export function not<T>(matcher: MaybeMatcher<T>): Matcher<T> {
   return {
@@ -8,5 +8,8 @@ export function not<T>(matcher: MaybeMatcher<T>): Matcher<T> {
     description(): string {
       return `not ${matcherDescription(matcher)}`;
     },
+    code(): string {
+      return `not(${matcherCode(matcher)})`
+    }
   }
 }

package/src/matchers/or.ts

@@ -1,4 +1,4 @@
-import { Matcher, MaybeMatcher, matcherDescription, applyMatcher } from '../matcher';
+import { Matcher, MaybeMatcher, matcherDescription, applyMatcher, matcherCode } from '../matcher';
 
 export function or<T>(...args: MaybeMatcher<T>[]): Matcher<T> {
   return {
@@ -8,5 +8,8 @@ export function or<T>(...args: MaybeMatcher<T>[]): Matcher<T> {
     description(): string {
       return args.map(matcherDescription).join(' or ');
     },
+    code(): string {
+      return `or(${args.map(arg => matcherCode(arg)).join(', ')})`
+    }
   }
 }

package/src/matchers/some.ts

@@ -1,4 +1,4 @@
-import { Matcher, MaybeMatcher, applyMatcher, matcherDescription } from '../matcher';
+import { Matcher, MaybeMatcher, applyMatcher, matcherDescription, matcherCode } from '../matcher';
 
 export function some<T>(expected: MaybeMatcher<T>): Matcher<Iterable<T>> {
   return {
@@ -8,5 +8,8 @@ export function some<T>(expected: MaybeMatcher<T>): Matcher<Iterable<T>> {
     description(): string {
       return `some item ${matcherDescription(expected)}`;
     },
+    code(): string {
+      return `some(${matcherCode(expected)})`
+    }
   }
 }

package/src/resolvers.ts

@@ -0,0 +1,100 @@
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { globals } from '@interactors/globals';
+import { Match } from './match';
+import { NoSuchElementError, NotAbsentError, AmbiguousElementError } from './errors';
+import { formatDescription, formatMatchesTable } from './format';
+import { InteractorOptions } from './specification';
+
+const defaultSelector = 'div';
+
+export function findElements<E extends Element>(parentElement: Element, interactor: InteractorOptions<any, any, any>): E[] {
+  if (!interactor.name) {
+    throw new Error('One of your interactors was created without a name. Please provide a label for your interactor:\n\tHTML.extend(\'my interactor\') || createInteractor(\'my interactor\')');
+  }
+  if (typeof interactor.specification.selector === 'function') {
+    return interactor.specification.selector(parentElement);
+  } else if (interactor.specification.selector === ':root') {
+    // this is a bit of a hack, because otherwise there isn't a good way of selecting the root element
+    return [parentElement.ownerDocument.querySelector(':root') as E];
+  } else {
+    return Array.from(parentElement.querySelectorAll(interactor.specification.selector || defaultSelector));
+  }
+}
+
+function findMatches(parentElement: Element, interactor: InteractorOptions<any, any, any>): Match<Element, any>[] {
+  return findElements(parentElement, interactor).map((e) => new Match(e, interactor.filter, interactor.locator));
+}
+
+function throwNoSuchElementError(matches: Match<Element, any>[], interactor: InteractorOptions<any, any, any>): never {
+  if (matches.length === 0) {
+    throw new NoSuchElementError(`did not find ${formatDescription(interactor)}`);
+  } else {
+    throw new NoSuchElementError(`did not find ${formatDescription(interactor)}, did you mean one of:\n\n${formatMatchesTable(interactor, matches)}`);
+  }
+}
+
+function findFirstMatch(parentElement: Element, interactor: InteractorOptions<any, any, any>): Match<Element, any> {
+  let matches: Match<Element, any>[] = []
+  for (let element of findElements(parentElement, interactor)) {
+    let match = new Match(element, interactor.filter, interactor.locator)
+    matches.push(match)
+    if (match.matches) {
+      return match
+    }
+  }
+  throwNoSuchElementError(matches, interactor);
+}
+
+export function hasMatchMatching(parentElement: Element, interactor: InteractorOptions<any, any, any>): boolean {
+  return findElements(parentElement, interactor).some(element => new Match(element, interactor.filter, interactor.locator).matches);
+}
+
+function findMatchesNonEmpty(parentElement: Element, interactor: InteractorOptions<any, any, any>): Match<Element, any>[] {
+  let matches = findMatches(parentElement, interactor);
+  let matching = matches.filter((m) => m.matches);
+  if (matching.length > 0) {
+    return matching;
+  }
+  throwNoSuchElementError(matches, interactor);
+}
+
+// Given a parent element, and an interactor, find exactly one matching element
+// and return it. If no elements match, raise an error. If more than one
+// element matches, raise an error.
+export function resolveUnique(parentElement: Element, interactor: InteractorOptions<any, any, any>): Element {
+  let matching = findMatchesNonEmpty(parentElement, interactor);
+
+  if (matching.length === 1) {
+    return matching[0].element;
+  } else {
+    let alternatives = matching.map((m) => '- ' + m.elementDescription());
+    throw new AmbiguousElementError(`${formatDescription(interactor)} matches multiple elements:\n\n${alternatives.join('\n')}`);
+  }
+}
+
+// Given a parent element, and an interactor, find the first matching element and
+// return it. If no elements match, raise an error.
+export function resolveFirst(parentElement: Element, interactor: InteractorOptions<any, any, any>): Element {
+  return findFirstMatch(parentElement, interactor).element
+}
+
+// Given a parent element, and an interactor, check if there are any matching
+// elements, and throw an error if there are. Otherwise return undefined.
+export function resolveEmpty(parentElement: Element, interactor: InteractorOptions<any, any, any>): void {
+  let matching = findMatches(parentElement, interactor).filter((m) => m.matches)
+
+  if (matching.length !== 0) {
+    let alternatives = matching.map((m) => '- ' + m.elementDescription());
+    throw new NotAbsentError(`${formatDescription(interactor)} exists but should not:\n\n${alternatives.join('\n')}`);
+  }
+}
+
+export function unsafeSyncResolveParent(options: InteractorOptions<any, any, any>): Element {
+  return options.ancestors.reduce(resolveUnique, globals.document.documentElement);
+}
+
+export function unsafeSyncResolveUnique<E extends Element>(options: InteractorOptions<E, any, any>): E {
+  return resolveUnique(unsafeSyncResolveParent(options), options) as E;
+}

package/src/serialize.ts

@@ -0,0 +1,54 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { InteractionOptions as SerializedInteractionOptions, InteractionType } from "@interactors/globals";
+import { pascalCase } from "change-case";
+import { InteractionOptions } from "./interaction";
+import { matcherCode } from "./matcher";
+import { InteractorOptions } from "./specification";
+
+export function serializeInteractorOptions(options: InteractorOptions<any, any, any>): {
+  interactor: string;
+  filter: { [name: string]: unknown };
+  locator: string;
+  code: () => string;
+} {
+  let locator = matcherCode(options.locator?.value);
+  return {
+    interactor: options.name,
+    filter: options.filter.all,
+    locator,
+    code() {
+      let interactorName = pascalCase(options.name);
+      let filters = Object.entries(options.filter.all).map(([name, filter]) => `"${name}": ${matcherCode(filter)}`);
+      return `${interactorName}(${[locator, filters.length && `{ ${filters.join(", ")} }`]
+        .filter(Boolean)
+        .join(", ")})`;
+    },
+  };
+}
+
+export function serializeInteractionOptions<E extends Element, T>(
+  type: InteractionType,
+  { name, interactor: { options }, args, filters }: InteractionOptions<E, T>
+): SerializedInteractionOptions {
+  let interactor = serializeInteractorOptions(options);
+  let ancestors = options.ancestors.map((ancestor) => serializeInteractorOptions(ancestor));
+  return {
+    ...interactor,
+    ancestors,
+    name,
+    type,
+    args: filters ? [filters] : args ? args : undefined,
+    code() {
+      let serializedArgs = "";
+      if (filters) {
+        let serializedFilters = Object.entries(filters).map(([name, filter]) => `"${name}": ${matcherCode(filter)}`);
+        serializedArgs = `{ ${serializedFilters.join(", ")} }`;
+      } else if (args) {
+        serializedArgs = args.map((arg) => JSON.stringify(arg)).join(", ");
+      }
+      return `${[...ancestors, interactor]
+        .map(({ code }, index) => (index == 0 ? code() : `${code()})`))
+        .join(".find(")}.${name}(${serializedArgs})`;
+    },
+  };
+}