@interactors/core 1.0.0-rc1.1 → 1.0.0-rc1.3

package/src/constructor.ts

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { globals } from '@interactors/globals';
 import { converge } from './converge';
 import { MergeObjects } from './merge-objects';
 import {
@@ -19,98 +18,14 @@ import {
 import { FilterSet } from './filter-set';
 import { Locator } from './locator';
 import { MatchFilter, applyFilter } from './match';
-import { formatTable } from './format-table';
+import { formatDescription } from './format';
 import { FilterNotMatchingError } from './errors';
-import { interaction, interactionFilter, check, checkFilter, Interaction, ReadonlyInteraction } from './interaction';
-import { Match } from './match';
-import { NoSuchElementError, NotAbsentError, AmbiguousElementError } from './errors';
+import { createInteraction, AssertionInteraction, ActionInteraction } from './interaction';
 import { isMatcher } from './matcher';
 import { matching } from './matchers/matching';
+import { hasMatchMatching, resolveEmpty, resolveFirst, resolveUnique, unsafeSyncResolveParent, unsafeSyncResolveUnique } from './resolvers';
 
 const defaultLocator: FilterDefinition<string, Element> = (element) => element.textContent || "";
-const defaultSelector = 'div';
-
-export function findElements<E extends Element>(parentElement: Element, interactor: InteractorOptions<any, any, any>): E[] {
-  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>[] {
-  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\')');
-  }
-  return findElements(parentElement, interactor).map((e) => new Match(e, interactor.filter, interactor.locator));
-}
-
-function findMatchesMatching(parentElement: Element, interactor: InteractorOptions<any, any, any>): Match<Element, any>[] {
-  return findMatches(parentElement, interactor).filter((m) => m.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;
-  } else if(matches.length === 0) {
-    throw new NoSuchElementError(`did not find ${description(interactor)}`);
-  } else {
-    let table = 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()),
-    });
-    throw new NoSuchElementError(`did not find ${description(interactor)}, did you mean one of:\n\n${table}`);
-  }
-}
-
-// 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(`${description(interactor)} matches multiple elements:\n\n${alternatives.join('\n')}`);
-  }
-}
-
-// Given a parent element, and an interactor, find all matching elements and
-// return them. If no elements match, raise an error.
-export function resolveNonEmpty(parentElement: Element, interactor: InteractorOptions<any, any, any>): Element[] {
-  return findMatchesNonEmpty(parentElement, interactor).map(m => m.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 = findMatchesMatching(parentElement, interactor);
-
-  if(matching.length !== 0) {
-    let alternatives = matching.map((m) => '- ' + m.elementDescription());
-    throw new NotAbsentError(`${description(interactor)} exists but should not:\n\n${alternatives.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();
-  }
-}
-
-function description(options: InteractorOptions<any, any, any>): string {
-  let ancestorsAndSelf: InteractorOptions<any, any, any>[] = options.ancestors.concat(options);
-  return ancestorsAndSelf.reverse().map(ownDescription).join(' within ');
-}
 
 /**
  * Removes any default values for a filter from the lookup if that filter is present in the
@@ -131,51 +46,56 @@ function getLookupFilterForAssertion<E extends Element, F extends Filters<E>>(fi
   return lookupFilter;
 }
 
-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;
-}
-
-export function instantiateInteractor<E extends Element, F extends Filters<E>, A extends Actions<E>>(
+export function instantiateInteractor<E extends Element, F extends Filters<E>, A extends Actions<E, Interactor<E, FilterParams<E, F>>>>(
   options: InteractorOptions<E, F, A>,
   resolver: (options: InteractorOptions<E, F, A>) => E
-): Interactor<E, FilterParams<E, F>> & ActionMethods<E, A> {
+): Interactor<E, FilterParams<E, F>> & FilterMethods<E, F> & ActionMethods<E, A, Interactor<E, FilterParams<E, F>>> {
   let interactor = {
     options,
 
     get description(): string {
-      return description(options);
+      return formatDescription(options);
     },
 
-    perform<T>(fn: (element: E) => T): Interaction<T> {
-      return interaction(`run perform on ${description(options)}`, () => converge(() => fn(resolver(options))))
+    perform<T>(fn: (element: E) => T): ActionInteraction<E, T> {
+      return createInteraction('action', {
+        name: "perform",
+        interactor,
+        args: [],
+        description: `run perform on ${formatDescription(options)}`,
+        run: (interactor) => converge(() => fn(resolver(interactor.options))),
+      });
     },
 
-    assert(fn: (element: E) => void): ReadonlyInteraction<void> {
-      return check(`${description(options)} asserts`, () => {
-        return converge(() => {
-          fn(resolver(options));
-        });
+    assert(fn: (element: E) => void): AssertionInteraction<E> {
+      return createInteraction('assertion', {
+        name: "assert",
+        interactor,
+        args: [],
+        description: `${formatDescription(options)} asserts`,
+        run: (interactor) => converge(() => { fn(resolver(interactor.options)) }),
       });
     },
 
-    has(filters: FilterParams<E, F>): ReadonlyInteraction<void> {
+    has(filters: FilterParams<E, F>): AssertionInteraction<E> {
       return interactor.is(filters);
     },
 
-    is(filters: FilterParams<E, F>): ReadonlyInteraction<void> {
+    is(filters: FilterParams<E, F>): AssertionInteraction<E> {
       let filter = new FilterSet(options.specification, filters);
-      return check(`${description(options)} matches filters: ${filter.description}`, () => {
-        return converge(() => {
-          let element = resolver({...options, filter: getLookupFilterForAssertion(options.filter, filters) });
+      return createInteraction('assertion', {
+        name: "is",
+        interactor,
+        args: [filters],
+        filters,
+        description: `${formatDescription(options)} matches filters: ${filter.description}`,
+        run: (interactor) => converge(() => {
+          let element = resolver({...interactor.options, filter: getLookupFilterForAssertion(interactor.options.filter, filters) });
           let match = new MatchFilter(element, filter);
           if (!match.matches) {
-            throw new FilterNotMatchingError(`${description(options)} does not match filters:\n\n${match.formatAsExpectations()}`);
+            throw new FilterNotMatchingError(`${formatDescription(options)} does not match filters:\n\n${match.formatAsExpectations()}`);
           }
-        });
+        }),
       });
     },
 
@@ -186,24 +106,28 @@ export function instantiateInteractor<E extends Element, F extends Filters<E>, A
       }, resolver) as unknown as T;
     },
 
-    exists(): ReadonlyInteraction<void> & FilterObject<boolean, Element> {
-      return checkFilter(`${description(options)} exists`, () => {
-        return converge(() => {
-          resolveNonEmpty(unsafeSyncResolveParent(options), options);
-        });
-      }, (element) => {
-        return findMatchesMatching(element, options).length > 0;
-      });
+    exists(): AssertionInteraction<E> & FilterObject<boolean, Element> {
+      return createInteraction('assertion', {
+        name: 'exists',
+        interactor,
+        args: [],
+        description: `${formatDescription(options)} exists`,
+        run: (interactor) => converge(() => {
+          resolveFirst(unsafeSyncResolveParent(interactor.options), options);
+        }),
+      }, (element) => hasMatchMatching(element, options));
     },
 
-    absent(): ReadonlyInteraction<void> & FilterObject<boolean, Element> {
-      return checkFilter(`${description(options)} does not exist`, () => {
-        return converge(() => {
-          resolveEmpty(unsafeSyncResolveParent(options), options);
-        });
-      }, (element) => {
-        return findMatchesMatching(element, options).length === 0;
-      });
+    absent(): AssertionInteraction<E> & FilterObject<boolean, Element> {
+      return createInteraction('assertion', {
+        name: 'absent',
+        interactor,
+        args: [],
+        description: `${formatDescription(options)} does not exist`,
+        run: (interactor) => converge(() => {
+          resolveEmpty(unsafeSyncResolveParent(interactor.options), options);
+        }),
+      }, (element) => !hasMatchMatching(element, options));
     },
 
     apply(parentElement: Element): string {
@@ -220,10 +144,13 @@ export function instantiateInteractor<E extends Element, F extends Filters<E>, A
           if (args.length) {
             actionDescription += ` with ` + args.map((a) => JSON.stringify(a)).join(', ');
           }
-          return interaction(
-            `${actionDescription} on ${description(options)}`,
-            () => action(interactor as Interactor<E, FilterParams<E, F>> & ActionMethods<E, A>, ...args)
-          );
+          return createInteraction('action', {
+            name: actionName,
+            interactor,
+            args,
+            description: `${actionDescription} on ${formatDescription(options)}`,
+            run: (interactor) => action(interactor as Interactor<E, FilterParams<E, F>> & FilterMethods<E, F> & ActionMethods<E, A, Interactor<E, FilterParams<E, F>>>, ...args)
+          });
         },
         configurable: true,
         writable: true,
@@ -236,8 +163,12 @@ export function instantiateInteractor<E extends Element, F extends Filters<E>, A
     if (!interactor.hasOwnProperty(filterName)) {
       Object.defineProperty(interactor, filterName, {
         value: function() {
-          return interactionFilter(`${filterName} of ${description(options)}`, async () => {
-            return converge(() => applyFilter(filter,  resolver(options)));
+          return createInteraction('assertion', {
+            name: filterName,
+            interactor,
+            args: [],
+            description: `${filterName} of ${formatDescription(options)}`,
+            run: (interactor) => converge(() => applyFilter(filter, resolver(interactor.options))),
           }, (parentElement) => {
             let element = [...options.ancestors, options].reduce(resolveUnique, parentElement);
             return applyFilter(filter, element);
@@ -250,10 +181,10 @@ export function instantiateInteractor<E extends Element, F extends Filters<E>, A
     }
   }
 
-  return interactor as Interactor<E, FilterParams<E, F>> & ActionMethods<E, A>;
+  return interactor as Interactor<E, FilterParams<E, F>> & FilterMethods<E, F> & ActionMethods<E, A, Interactor<E, FilterParams<E, F>>>;
 }
 
-export function createConstructor<E extends Element, FP extends FilterParams<any, any>, FM extends FilterMethods<any, any>, AM extends ActionMethods<any, any>>(
+export function createConstructor<E extends Element, FP extends FilterParams<any, any>, FM extends FilterMethods<any, any>, AM extends ActionMethods<any, any, any>>(
   name: string,
   specification: InteractorSpecification<E, any, any>,
 ): InteractorConstructor<E, FP, FM, AM> {
@@ -270,6 +201,7 @@ export function createConstructor<E extends Element, FP extends FilterParams<any
   }
 
   return Object.assign(initInteractor, {
+    interactorName: name,
     selector: (value: string): InteractorConstructor<E, FP, FM, AM> => {
       return createConstructor(name, { ...specification, selector: value });
     },
@@ -279,7 +211,7 @@ export function createConstructor<E extends Element, FP extends FilterParams<any
     filters: <FR extends Filters<E>>(filters: FR): InteractorConstructor<E, MergeObjects<FP, FilterParams<E, FR>>, MergeObjects<FM, FilterMethods<E, FR>>, AM> => {
       return createConstructor(name, { ...specification, filters: { ...specification.filters, ...filters } });
     },
-    actions: <AR extends Actions<E>>(actions: AR): InteractorConstructor<E, FP, FM, MergeObjects<AM, ActionMethods<E, AR>>> => {
+    actions: <I extends Interactor<E, FP> & FM & AM, AR extends Actions<E, I>>(actions: AR): InteractorConstructor<E, FP, FM, MergeObjects<AM, ActionMethods<E, AR, I>>> => {
       return createConstructor(name, { ...specification, actions: Object.assign({}, specification.actions, actions) });
     },
     extend: <ER extends Element = E>(newName: string): InteractorConstructor<ER, FP, FM, AM> => {

package/src/converge.ts

@@ -1,11 +1,8 @@
+import { Operation, sleep } from '@effection/core';
 import { performance } from 'performance-api';
 import { globals } from '@interactors/globals'
 
-function wait(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export async function converge<T>(fn: () => T): Promise<T> {
+export function* converge<T>(fn: () => T): Operation<T> {
   let startTime = performance.now();
   while(true) {
     try {
@@ -15,7 +12,7 @@ export async function converge<T>(fn: () => T): Promise<T> {
       if(diff > globals.interactorTimeout) {
         throw e;
       } else {
-        await wait(1);
+        yield sleep(1);
       }
     }
   }

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>;
 
-  [interactionSymbol]: true
+  halt: () => Promise<void>;
+
+  [interactionSymbol]: true;
+}
+
+export interface ActionInteraction<E extends Element, T = void> extends Interaction<E, T> {
+  type: "action";
+  check: undefined;
 }
 
 /**
@@ -36,47 +60,88 @@ 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>;
+  let shouldCatchHalt = false
+
+  function operation(scope: Task): Operation<T> {
+    let run = () => options.run(options.interactor);
+
+    return (globals.wrapInteraction
+      ? globals.wrapInteraction(() => scope.run(run), interaction)
+      : globals.wrapAction(interaction.description, () => scope.run(run), type)) as Operation<T>;
+  };
+
+  function action(): Task<T> {
+    if(!task) {
+      task = run(operation);
+    }
+    return task;
+  };
+
+  function catchHalt<T extends (reason: any) => any>(onReject?: T | null) {
+    return (reason: any) => {
+      if (shouldCatchHalt && reason instanceof Error && reason.message == 'halted') {
+        return reason
+      } else {
+        onReject?.(reason)
+        return reason
+      }
+    }
+  }
+
+  let serializedOptions = serializeInteractionOptions(type, options)
+  let interaction: Interaction<E, T> & Operation<T> = {
+    type,
+    options: serializedOptions,
+    description: options.description,
+    interactor: options.interactor,
+    run: options.run,
+    args: options.args,
     action,
+    check: type === 'assertion' ? action : undefined,
+    code: () => serializedOptions.code(),
+    halt: () => {
+      shouldCatchHalt = true
+      return 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, catchHalt(onReject));
     },
     catch(onReject) {
-      if(!promise) { promise = this.action(); }
-      return promise.catch(onReject);
+      return action().catch(catchHalt(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;
+  }
 }