@interactors/core 0.3.0 → 1.0.0-effection.1

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 {
@@ -14,104 +13,19 @@ import {
   FilterParams,
   FilterMethods,
   InteractorSpecification,
-  BaseInteractor,
   FilterObject,
 } from './specification';
 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
@@ -132,59 +46,90 @@ 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 instantiateBaseInteractor<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
-): BaseInteractor<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,
+        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,
+        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,
+        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()}`);
           }
-        });
+        }),
       });
     },
 
+    find<T extends Interactor<any, any>>(child: T): T {
+      return instantiateInteractor({
+        ...child.options,
+        ancestors: [...options.ancestors, options, ...child.options.ancestors]
+      }, resolver) as unknown as T;
+    },
+
+    exists(): AssertionInteraction<E> & FilterObject<boolean, Element> {
+      return createInteraction('assertion', {
+        name: 'exists',
+        interactor,
+        description: `${formatDescription(options)} exists`,
+        run: (interactor) => converge(() => {
+          resolveFirst(unsafeSyncResolveParent(interactor.options), options);
+        }),
+      }, (element) => hasMatchMatching(element, options));
+    },
+
+    absent(): AssertionInteraction<E> & FilterObject<boolean, Element> {
+      return createInteraction('assertion', {
+        name: 'absent',
+        interactor,
+        description: `${formatDescription(options)} does not exist`,
+        run: (interactor) => converge(() => {
+          resolveEmpty(unsafeSyncResolveParent(interactor.options), options);
+        }),
+      }, (element) => !hasMatchMatching(element, options));
+    },
+
     apply(parentElement: Element): string {
       let element = [...options.ancestors, options].reduce(resolveUnique, parentElement);
       return applyFilter(options.specification.locator || defaultLocator, element);
     }
-  }
+  };
 
   for (let [actionName, action] of Object.entries(options.specification.actions || {})) {
     if (!interactor.hasOwnProperty(actionName)) {
@@ -194,10 +139,13 @@ export function instantiateBaseInteractor<E extends Element, F extends Filters<E
           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,
@@ -210,8 +158,11 @@ export function instantiateBaseInteractor<E extends Element, F extends Filters<E
     if (!interactor.hasOwnProperty(filterName)) {
       Object.defineProperty(interactor, filterName, {
         value: function() {
-          return interactionFilter(`${filterName} of ${description(options)}`, async () => {
-            return applyFilter(filter, resolver(options));
+          return createInteraction('assertion', {
+            name: filterName,
+            interactor,
+            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);
@@ -224,45 +175,10 @@ export function instantiateBaseInteractor<E extends Element, F extends Filters<E
     }
   }
 
-  return interactor as BaseInteractor<E, FilterParams<E, F>> & ActionMethods<E, A>;
-}
-
-export function instantiateInteractor<E extends Element, F extends Filters<E>, A extends Actions<E>>(
-  options: InteractorOptions<E, F, A>,
-): Interactor<E, FilterParams<E, F>> & ActionMethods<E, A> {
-  let interactor = instantiateBaseInteractor(options, unsafeSyncResolveUnique)
-
-  return Object.assign(interactor, {
-    find<T extends Interactor<any, any>>(child: T): T {
-      return instantiateInteractor({
-        ...child.options,
-        ancestors: [...options.ancestors, options, ...child.options.ancestors]
-      }) 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;
-      });
-    },
-
-    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;
-      });
-    }
-  });
+  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> {
@@ -275,7 +191,7 @@ export function createConstructor<E extends Element, FP extends FilterParams<any
     } else {
       filter = new FilterSet(specification, args[0] || {});
     }
-    return instantiateInteractor({ name, specification, filter, locator, ancestors: [] });
+    return instantiateInteractor({ name, specification, filter, locator, ancestors: [] }, unsafeSyncResolveUnique);
   }
 
   return Object.assign(initInteractor, {
@@ -288,7 +204,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,12 +1,9 @@
-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 { perform } from './perform';
-export { focused, focus, blur } from './focused';
 export { isVisible } from 'element-is-visible';
 export { Matcher } from './matcher';
-export * from './dispatch';
 
 export { including } from './matchers/including';
 export { matching } from './matchers/matching';
@@ -16,5 +13,6 @@ export { not } from './matchers/not';
 export { some } from './matchers/some';
 export { every } from './matchers/every';
 
-export { fillIn } from './element/fill-in';
 export { click } from './element/click';
+export { MergeObjects } from './merge-objects'
+export { MaybeMatcher } from './matcher'

package/src/inspector.ts

@@ -1,13 +1,14 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { instantiateBaseInteractor, findElements, unsafeSyncResolveParent } from "./constructor";
-import { BaseInteractor, Filters, InteractorConstructor, FilterParams } from "./specification";
+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
 type GetFilters<I extends InteractorConstructor<any, any, any, any>> = I extends InteractorConstructor<any, infer F, any, any> ? F : never
 type GetActions<I extends InteractorConstructor<any, any, any, any>> = I extends InteractorConstructor<any, any, any, infer A> ? A : never
 
-export interface InteractorInspector<E extends Element, FP extends FilterParams<any, any>> extends BaseInteractor<E, FP> {
+export interface InteractorInspector<E extends Element, FP extends FilterParams<any, any>> extends Omit<Interactor<E, FP>, 'find'> {
   element: E,
   find<T extends InteractorConstructor<any, any, any, any>>(interactor: T): Inspector<T>
 }
@@ -30,7 +31,7 @@ export function createInspector<IC extends InteractorConstructor<any, any, any,
       let elements = findElements<GetElement<IC>>(parentElement ?? unsafeSyncResolveParent(options), options);
       return elements.map(
         element => (Object.assign(
-          instantiateBaseInteractor(options, () => element) as (BaseInteractor<GetElement<IC>, Filters<GetFilters<IC>>> & GetActions<IC>), {
+          instantiateInteractor(options, () => element) as (Interactor<GetElement<IC>, Filters<GetFilters<IC>>> & GetActions<IC>), {
           element,
           find<T extends InteractorConstructor<any, any, any, any>>(constructor: T): Inspector<T> {
             return createInspector(constructor, element)

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,72 @@ 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(scope: Task): Operation<T> {
+    let run = () => options.run(options.interactor);
+
+    return (globals.wrapInteraction
+      ? globals.wrapInteraction(interaction, () => scope.run(run))
+      : globals.wrapAction(interaction.description, () => scope.run(run), type)) 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;
+  }
 }