@interactors/core 0.3.0 → 1.0.0-effection.1

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})`;
+    },
+  };
+}

package/src/specification.ts

@@ -1,49 +1,28 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+import { Operation } from '@effection/core';
 import { FilterSet } from './filter-set';
 import { Locator } from './locator';
-import { Interaction, ReadonlyInteraction } from './interaction';
+import { ActionInteraction, AssertionInteraction } from './interaction';
 import { MergeObjects } from './merge-objects';
 import { MaybeMatcher } from './matcher';
 
 export type EmptyObject = Record<never, never>;
 
-export interface ExistsAssertionsImplementation {
-
-  /**
-   * An assertion which checks that an element matching the interactor exists.
-   * Throws an error if the element does not exist.
-   *
-   * ## Example
-   *
-   * ``` typescript
-   * await Link('Next').exists();
-   * ```
-   */
-  exists(): ReadonlyInteraction<void> & FilterObject<boolean, Element>;
-
-  /**
-   * An assertion which checks that an element matching the interactor does not
-   * exist. Throws an error if the element exists.
-   *
-   * ## Example
-   *
-   * ``` typescript
-   * await Link('Next').absent();
-   * ```
-   */
-  absent(): ReadonlyInteraction<void> & FilterObject<boolean, Element>;
-}
-
-export interface BaseInteractor<E extends Element, F extends FilterParams<any, any>> {
+/**
+ * Instances of an interactor returned by an {@link InteractorConstructor}, use
+ * this class as its base. They are also extended with any additional actions
+ * defined in their {@link InteractorSpecification}.
+ */
+export interface Interactor<E extends Element, F extends FilterParams<any, any>> {
   /**
    * @hidden
    */
   options: InteractorOptions<E, any, any>;
 
-  /**
-   * @returns a human readable description of this interactor
-   */
+   /**
+    * @returns a human readable description of this interactor
+    */
   description: string;
 
   /**
@@ -60,7 +39,7 @@ export interface BaseInteractor<E extends Element, F extends FilterParams<any, a
    * await Link('Next').perform((e) => e.click());
    * ```
    */
-  perform(fn: (element: E) => void): Interaction<void>;
+  perform(fn: (element: E) => void): ActionInteraction<E, void>;
 
   /**
    * Perform a one-off assertion on the given interactor. Takes a function which
@@ -76,7 +55,31 @@ export interface BaseInteractor<E extends Element, F extends FilterParams<any, a
    * await Link('Next').assert((e) => assert(e.tagName === 'A'));
    * ```
    */
-  assert(fn: (element: E) => void): ReadonlyInteraction<void>;
+  assert(fn: (element: E) => void): AssertionInteraction<E, void>;
+
+  /**
+   * An assertion which checks that an element matching the interactor exists.
+   * Throws an error if the element does not exist.
+   *
+   * ## Example
+   *
+   * ``` typescript
+   * await Link('Next').exists();
+   * ```
+   */
+  exists(): AssertionInteraction<E, void> & FilterObject<boolean, Element>;
+
+  /**
+   * An assertion which checks that an element matching the interactor does not
+   * exist. Throws an error if the element exists.
+   *
+   * ## Example
+   *
+   * ``` typescript
+   * await Link('Next').absent();
+   * ```
+   */
+  absent(): AssertionInteraction<E, void> & FilterObject<boolean, Element>;
 
   /**
    * Checks that there is one element matching the interactor, and that this
@@ -89,7 +92,7 @@ export interface BaseInteractor<E extends Element, F extends FilterParams<any, a
    * await Link('Home').has({ href: '/' })
    * ```
    */
-  has(filters: F): ReadonlyInteraction<void>;
+  has(filters: F): AssertionInteraction<E, void>;
 
   /**
    * Identical to {@link has}, but reads better with some filters.
@@ -100,20 +103,8 @@ export interface BaseInteractor<E extends Element, F extends FilterParams<any, a
    * await CheckBox('Accept conditions').is({ checked: true })
    * ```
    */
-  is(filters: F): ReadonlyInteraction<void>;
+  is(filters: F): AssertionInteraction<E, void>;
 
-  /**
-   * @hidden
-   */
-  apply: FilterFn<string, Element>;
-}
-
-/**
- * Instances of an interactor returned by an {@link InteractorConstructor}, use
- * this class as its base. They are also extended with any additional actions
- * defined in their {@link InteractorSpecification}.
- */
-export interface Interactor<E extends Element, F extends FilterParams<any, any>> extends BaseInteractor<E, F>, ExistsAssertionsImplementation {
   /**
    * Returns a copy of the given interactor which is scoped to this interactor.
    * When there are multiple matches for an interactor, this makes it possible
@@ -130,10 +121,15 @@ export interface Interactor<E extends Element, F extends FilterParams<any, any>>
    * @returns a scoped copy of the initial interactor
    * @typeParam T the type of the interactor that we are going to scope
    */
-   find<T extends Interactor<any, any>>(interactor: T): T;
+  find<T extends Interactor<any, any>>(interactor: T): T;
+
+  /**
+   * @hidden
+   */
+  apply: FilterFn<string, Element>;
 }
 
-export type ActionFn<E extends Element> = (interactor: Interactor<E, EmptyObject>, ...args: any[]) => Promise<unknown>;
+export type ActionFn<E extends Element, I extends Interactor<E, any>> = (interactor: I, ...args: any[]) => Operation<unknown>;
 
 export type FilterFn<T, E extends Element> = (element: E) => T;
 
@@ -146,11 +142,11 @@ export type FilterDefinition<T, E extends Element> = FilterFn<T, E> | FilterObje
 
 export type Filters<E extends Element> = Record<string, FilterDefinition<unknown, E>>;
 
-export type Actions<E extends Element> = Record<string, ActionFn<E>>;
+export type Actions<E extends Element, I extends Interactor<E, any>> = Record<string, ActionFn<E, I>>;
 
 export type SelectorFn<E extends Element> = (parentElement: Element) => E[];
 
-export type InteractorSpecification<E extends Element, F extends Filters<E>, A extends Actions<E>> = {
+export type InteractorSpecification<E extends Element, F extends Filters<E>, A extends Actions<E, Interactor<E, EmptyObject>>> = {
   /**
    * The CSS selector that this interactor uses to find matching elements
    */
@@ -166,16 +162,16 @@ export type InteractorSpecification<E extends Element, F extends Filters<E>, A e
   locator?: FilterDefinition<string, E>;
 }
 
-export type ActionMethods<E extends Element, A extends Actions<E>> = {
-  [P in keyof A]: A[P] extends ((interactor: Interactor<E, EmptyObject>, ...args: infer TArgs) => Promise<infer TReturn>)
-    ? ((...args: TArgs) => Interaction<TReturn>)
+export type ActionMethods<E extends Element, A extends Actions<E, I>, I extends Interactor<E, any>> = {
+  [P in keyof A]: A[P] extends ((interactor: I, ...args: infer TArgs) => Operation<infer TReturn>)
+    ? ((...args: TArgs) => ActionInteraction<E, TReturn>)
     : never;
 }
 
 export type FilterMethods<E extends Element, F extends Filters<E>> = {
   [P in keyof F]:
-    F[P] extends FilterFn<infer TReturn, any> ? (() => Interaction<TReturn> & FilterObject<TReturn, Element>) :
-    F[P] extends FilterObject<infer TReturn, any> ? (() => Interaction<TReturn> & FilterObject<TReturn, Element>) :
+    F[P] extends FilterFn<infer TReturn, any> ? (() => AssertionInteraction<E, TReturn> & FilterObject<TReturn, Element>) :
+    F[P] extends FilterObject<infer TReturn, any> ? (() => AssertionInteraction<E, TReturn> & FilterObject<TReturn, Element>) :
     never;
 }
 
@@ -202,11 +198,11 @@ export type FilterParams<E extends Element, F extends Filters<E>> = keyof F exte
  * @typeParam F the filters of this interactor, this is usually inferred from the specification
  * @typeParam A the actions of this interactor, this is usually inferred from the specification
  */
-export interface InteractorConstructor<E extends Element, FP extends FilterParams<any, any>, FM extends FilterMethods<any, any>, AM extends ActionMethods<any, any>> {
+export interface InteractorConstructor<E extends Element, FP extends FilterParams<any, any>, FM extends FilterMethods<any, any>, AM extends ActionMethods<any, any, any>> {
   selector(value: string | SelectorFn<E>): InteractorConstructor<E, FP, FM, AM>;
   locator(value: FilterDefinition<string, E>): InteractorConstructor<E, FP, FM, AM>;
   filters<FR extends Filters<E>>(filters: FR): InteractorConstructor<E, MergeObjects<FP, FilterParams<E, FR>>, MergeObjects<FM, FilterMethods<E, FR>>, AM>;
-  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>>>;
   extend<ER extends E = E>(name: string): InteractorConstructor<ER, FP, FM, AM>;
 
   /**
@@ -230,6 +226,7 @@ export interface InteractorConstructor<E extends Element, FP extends FilterParam
    *
    * ``` typescript
    * Link('Home');
+   * Link(/^home/i);
    * ```
    *
    * Or with a locator and options:
@@ -241,10 +238,10 @@ export interface InteractorConstructor<E extends Element, FP extends FilterParam
    * @param value The locator value, which should match the value of applying the locator function defined in the {@link InteractorSpecification} to the element.
    * @param filters An object describing a set of filters to apply, which should match the value of applying the filters defined in the {@link InteractorSpecification} to the element.
    */
-  (value: MaybeMatcher<string>, filters?: FP): Interactor<E, FP> & FM & AM;
+  (value: MaybeMatcher<string> | RegExp, filters?: FP): Interactor<E, FP> & FM & AM;
 }
 
-export type InteractorOptions<E extends Element, F extends Filters<E>, A extends Actions<E>> = {
+export type InteractorOptions<E extends Element, F extends Filters<E>, A extends Actions<E, Interactor<E, EmptyObject>>> = {
   name: string;
   specification: InteractorSpecification<E, F, A>;
   locator?: Locator<E>;

package/CHANGELOG.md

@@ -1,14 +0,0 @@
-# @interactors/core
-
-## 0.3.0
-
-### Minor Changes
-
-- 53dea63: Enable delegation to locator of an interactor if no filter given
-
-## 0.2.0
-
-### Minor Changes
-
-- 0c96dab: Add locator delegation. Locators can be delegated to another delegator.
-- f4949ac: Selector can be a function to return arbitrary elements

package/dist/cjs/dispatch.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dispatchClick = exports.dispatchKeyUp = exports.dispatchKeyDown = exports.dispatchInput = exports.dispatchChange = void 0;
-function dispatchChange(element) {
-    var _a;
-    let Event = ((_a = element.ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.Event) || window.Event;
-    return element.dispatchEvent(new Event('change', { bubbles: true, cancelable: false }));
-}
-exports.dispatchChange = dispatchChange;
-function dispatchInput(element, options = {}) {
-    var _a;
-    let InputEvent = ((_a = element.ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.InputEvent) || window.InputEvent;
-    return element.dispatchEvent(new InputEvent('input', Object.assign({ bubbles: true, cancelable: false }, options)));
-}
-exports.dispatchInput = dispatchInput;
-function dispatchKeyDown(element, options = {}) {
-    var _a;
-    let KeyboardEvent = ((_a = element.ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.KeyboardEvent) || window.KeyboardEvent;
-    return element.dispatchEvent(new KeyboardEvent('keydown', Object.assign({ bubbles: true, cancelable: true }, options)));
-}
-exports.dispatchKeyDown = dispatchKeyDown;
-function dispatchKeyUp(element, options = {}) {
-    var _a;
-    let KeyboardEvent = ((_a = element.ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.KeyboardEvent) || window.KeyboardEvent;
-    return element.dispatchEvent(new KeyboardEvent('keyup', Object.assign({ bubbles: true, cancelable: true }, options)));
-}
-exports.dispatchKeyUp = dispatchKeyUp;
-function dispatchClick(element, options = {}) {
-    var _a;
-    let MouseEvent = ((_a = element.ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.MouseEvent) || window.MouseEvent;
-    return element.dispatchEvent(new MouseEvent('click', Object.assign({ bubbles: true, cancelable: true }, options)));
-}
-exports.dispatchClick = dispatchClick;
-//# sourceMappingURL=dispatch.js.map

package/dist/cjs/dispatch.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dispatch.js","sourceRoot":"","sources":["../../src/dispatch.ts"],"names":[],"mappings":";;;AAAA,SAAgB,cAAc,CAAC,OAAoB;;IACjD,IAAI,KAAK,GAAG,CAAA,MAAA,OAAO,CAAC,aAAa,CAAC,WAAW,0CAAE,KAAK,KAAI,MAAM,CAAC,KAAK,CAAC;IACrE,OAAO,OAAO,CAAC,aAAa,CAAC,IAAI,KAAK,CAAC,QAAQ,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;AAC1F,CAAC;AAHD,wCAGC;AAED,SAAgB,aAAa,CAAC,OAAoB,EAAE,UAA0B,EAAE;;IAC9E,IAAI,UAAU,GAAG,CAAA,MAAA,OAAO,CAAC,aAAa,CAAC,WAAW,0CAAE,UAAU,KAAI,MAAM,CAAC,UAAU,CAAC;IACpF,OAAO,OAAO,CAAC,aAAa,CAAC,IAAI,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;AACtH,CAAC;AAHD,sCAGC;AAED,SAAgB,eAAe,CAAC,OAAoB,EAAE,UAA6B,EAAE;;IACnF,IAAI,aAAa,GAAG,CAAA,MAAA,OAAO,CAAC,aAAa,CAAC,WAAW,0CAAE,aAAa,KAAI,MAAM,CAAC,aAAa,CAAC;IAC7F,OAAO,OAAO,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;AAC1H,CAAC;AAHD,0CAGC;AAED,SAAgB,aAAa,CAAC,OAAoB,EAAE,UAA6B,EAAE;;IACjF,IAAI,aAAa,GAAG,CAAA,MAAA,OAAO,CAAC,aAAa,CAAC,WAAW,0CAAE,aAAa,KAAI,MAAM,CAAC,aAAa,CAAC;IAC7F,OAAO,OAAO,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;AACxH,CAAC;AAHD,sCAGC;AAED,SAAgB,aAAa,CAAC,OAAoB,EAAE,UAA0B,EAAE;;IAC9E,IAAI,UAAU,GAAG,CAAA,MAAA,OAAO,CAAC,aAAa,CAAC,WAAW,0CAAE,UAAU,KAAI,MAAM,CAAC,UAAU,CAAC;IACpF,OAAO,OAAO,CAAC,aAAa,CAAC,IAAI,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;AACrH,CAAC;AAHD,sCAGC"}