ngx-speculoos 11.0.0 → 12.0.0

package/README.md

@@ -6,7 +6,7 @@
 ngx-speculoos helps you write simpler, cleaner unit tests for your Angular components, based on the
 *page object* pattern. It also provides utilities to make writing Angular unit tests easier.
 
-The library simply wraps the standard Angular ComponentFixture, and you should thus be 
+The library simply wraps the standard Angular ComponentFixture, and you should thus be
 able to understand and start using ngx-speculoos in just a few minutes if you already know
 how to write Angular unit tests.
 
@@ -27,7 +27,9 @@ how to write Angular unit tests.
     - [Subqueries](#subqueries)
   - [Dispatching events](#dispatching-events)
   - [Custom Jasmine matchers](#custom-jasmine-matchers)
-  - [Routing helper](#routing-helper)
+  - [Routing helpers](#routing-helpers)
+    - [ActivatedRoute stub](#activatedroute-stub)
+    - [RoutingTester](#routingtester)
   - [Mocking helper](#mocking-helper)
   - [Testing with a host component](#testing-with-a-host-component)
 - [Gotchas](#gotchas)
@@ -72,12 +74,12 @@ it('should hide cities when selecting the empty country option', () => {
 
 ngx-speculoos allows writing the above tests in a simpler, cleaner way:
 
- - by using the page object pattern (which is optional, but recommended), you avoid repetitions. 
- - by using wrappers around elements, dispatching events and triggering change detection is automatic.
- - by using wrappers around elements, you get useful additional methods to make tests easier to write and read.
- - by using custom matchers, you get even simpler expectations and more readable error messages
- - in any case you need them, you always have access to the fixture, the native elements, the debug elements, etc.
- 
+- by using the page object pattern (which is optional, but recommended), you avoid repetitions.
+- by using wrappers around elements, dispatching events and triggering change detection is automatic.
+- by using wrappers around elements, you get useful additional methods to make tests easier to write and read.
+- by using custom matchers, you get even simpler expectations and more readable error messages
+- in any case you need them, you always have access to the fixture, the native elements, the debug elements, etc.
+
 ```typescript
 class MyComponentTester extends ComponentTester<MyComponent> {
   constructor() {
@@ -119,17 +121,17 @@ Using yarn: `yarn add --dev ngx-speculoos`
 
 ### Getting started
 
- - import ComponentTester, and other needed classes from ngx-speculoos
- - Create a `MyComponentTester` class (in your `my-component.spec.ts` file, typically) extending 
-   `ComponentTester<MyComponent>`, as shown above.
- - Expose getters (or methods, if you prefer) returning the elements used in your tests, using
-   one of the ComponentTester methods (`element`, `elements`, `input`, `select`, `textarea`, `button`, etc.).
-   See the [API documentation](https://ngx-speculoos.ninja-squad.com/documentation/classes/ComponentTester.html) for details
- - Write your tests, as shown above, benefiting from the additional methods on the TestXxx classes.
- - If needed, you can always get the fixture, componentInstance, debugElement, nativeElement, etc.
-   from the ComponentTester, and the nativeElement from each TestXxx wrapper.
- - If you like our custom matchers, add them in a `beforeEach` block as shown above, and enjoy.
-   You can also add them for all tests at once by adding the beforeEach block to the CLI-generated `test.ts` file.
+- import ComponentTester, and other needed classes from ngx-speculoos
+- Create a `MyComponentTester` class (in your `my-component.spec.ts` file, typically) extending
+  `ComponentTester<MyComponent>`, as shown above.
+- Expose getters (or methods, if you prefer) returning the elements used in your tests, using
+  one of the ComponentTester methods (`element`, `elements`, `input`, `select`, `textarea`, `button`, etc.).
+  See the [API documentation](https://ngx-speculoos.ninja-squad.com/documentation/classes/ComponentTester.html) for details
+- Write your tests, as shown above, benefiting from the additional methods on the TestXxx classes.
+- If needed, you can always get the fixture, componentInstance, debugElement, nativeElement, etc.
+  from the ComponentTester, and the nativeElement from each TestXxx wrapper.
+- If you like our custom matchers, add them in a `beforeEach` block as shown above, and enjoy.
+  You can also add them for all tests at once by adding the beforeEach block to the CLI-generated `test.ts` file.
 
 ## Features in details
 
@@ -142,12 +144,12 @@ You can simply create one in your tests using
 const tester = new ComponentTester(MyComponent);
 ```
 
-and then use it to query for sub elements, components, directives, etc. But we recommend adopting the 
+and then use it to query for sub elements, components, directives, etc. But we recommend adopting the
 page object pattern, in order to make your test easier to write and read, and to avoid repeating the
-same selectors over and over again. 
+same selectors over and over again.
 
 You do that by writing a class that extends `ComponentTester`, and provides getters (or functions)
-to query for elements, components, etc. 
+to query for elements, components, etc.
 
 ```typescript
 class MyComponentTester extends ComponentTester<MyComponent> {
@@ -182,7 +184,7 @@ describe('My component', () => {
     tester.detectChanges();
   });
   
-  it ('should ...`, () => {
+  it('should ...', () => {
     
   });
 ```
@@ -191,16 +193,16 @@ describe('My component', () => {
 
 #### Queries for elements
 
-Most of the queries that ngx-speculoos supports are used to query for DOM elements. The queries, however, 
+Most of the queries that ngx-speculoos supports are used to query for DOM elements. The queries, however,
 don't actually returns native DOM elements, but wrappers around them, which are instances of `TestElement`.
 
 `TestElement` has more specialized subclasses: `TestHtmlElement`, `TestInput`, `TestSelect`, `TestTextarea`, `TestButton`.
 Those subclasses offer helpful methods to get information or dispatch events to HTML elements, inputs, selects, etc.
-Our custom matchers act on those `TestElement` objects. 
+Our custom matchers act on those `TestElement` objects.
 
 You can [create your own subclasses of TestElement](#queries-for-custom-testelement) and query for them, too.
 
-A TestElement is a wrapper around an Angular `DebugElement`. So it can access the `DebugElement` and the 
+A TestElement is a wrapper around an Angular `DebugElement`. So it can access the `DebugElement` and the
 native DOM element that it wraps. It also has an instance of the `ComponentTester` which created it,
 which itself wraps the Angular `ComponentFixture` and thus allows detecting changes automatically after
 an element has been dispatched, for example.
@@ -247,11 +249,11 @@ get reviewers() {
 
 #### Queries for injection tokens
 
-Querying using `element(DatepickerDirective)` will return you a `TestElement` on which the 
+Querying using `element(DatepickerDirective)` will return you a `TestElement` on which the
 `DatepickerDirective` has been applied.
 
 If you need to get the `Datepicker` directive instance itself, then use the `token()` method
-(or `tokens()` to get several of them) 
+(or `tokens()` to get several of them)
 which takes a selector (CSS or type) as first argument, and the token as second argument:
 
 ```typescript
@@ -349,7 +351,7 @@ or in all tests, by adding the above line of code in the `test.ts` file.
 
 ### Dispatching events
 
-`TestElement` provides two methods that allow dispatching events in a simple way. 
+`TestElement` provides two methods that allow dispatching events in a simple way.
 
 - `dispatchEvent(event: Event)`
 - `dispatchEventOfType(type: string)`
@@ -372,11 +374,13 @@ For example
 Creating your own TestElement subclasses is a good way to provide such custom methods to interact
 with your own reusable components in tests.
 
-### Routing helper
+### Routing helpers
+
+#### ActivatedRoute stub
 
-The library provides a stub for the `ActivatedRoute` class that you typically inject in your routing components.
+The library provides a stub for the `ActivatedRoute` class that you typically inject in your routed components.
 It mimics the behavior of the actual `ActivatedRoute`, by having a snapshot and observables that emit when this
-snapshot changes. And it also allows simulating navigations by imperatively changing the parameters, query parameters, 
+snapshot changes. And it also allows simulating navigations by imperatively changing the parameters, query parameters,
 etc.
 
 ```typescript
@@ -422,6 +426,67 @@ describe('routing component', () => {
 });
 ```
 
+#### RoutingTester
+
+An alternative approach to injecting a stub activated route consists in using the Angular `RouterTestingHarness`.
+The library helps using it by providing a `RoutingTester`, which is a `ComponentTester` wrapping the
+`RouterTestingHarness` in addition to wrapping its fixture, and additionally provides helper properties.
+
+Here's an example usage of a component displaying the value of the query parameter `'page'` and allowing
+to navigate to itself with a different value for that query parameter.
+
+```typescript
+class PageComponentTester extends RoutingTester {
+  constructor(harness: RouterTestingHarness) {
+    super(harness);
+  }
+
+  get title() {
+    return this.element('h1');
+  }
+
+  get link() {
+    return this.element('a');
+  }
+}
+
+describe('RoutingTester', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        provideRouter([
+          { path: 'list', component: PageComponent }
+        ])
+      ]
+    });
+  });
+
+  it('should display the page of the query params', async () => {
+    const tester = new PageComponentTester(await RouterTestingHarness.create('/list?page=42'));
+
+    expect(tester.title).toHaveText('Current page: 42');
+
+    await tester.harness.navigateByUrl('/list?page=54');
+
+    expect(tester.title).toHaveText('Current page: 54');
+  });
+
+  it('should navigate to the next page when clicking the link', async () => {
+    const tester = new PageComponentTester(await RouterTestingHarness.create('/list?page=42'));
+
+    expect(tester.title).toHaveText('Current page: 42');
+
+    tester.link.click();
+    await tester.stable();
+
+    expect(tester.urlTree.queryParamMap.get('page')).toBe('43');
+    expect(tester.url).toBe('/list?page=43');
+    expect(tester.title).toHaveText('Current page: 43');
+  });
+});
+
+```
+
 ### Mocking helper
 
 Jasmine is quite verbose when creating mock objects in a typesafe way:
@@ -431,7 +496,7 @@ const productService = jasmine.createSpyObj<ProductService>('ProductService', ['
 ```
 
 Since most of what we mock (usually Angular services) are classes, we can actually do a bit of introspection
-and create a mock that will automatically mock all the methods declared in the class. That's what our 
+and create a mock that will automatically mock all the methods declared in the class. That's what our
 `createMock()` function does. The above code can thus be reduced to:
 
 ```typescript
@@ -452,7 +517,7 @@ class HostComponent {
     id: 'u1',
     name: 'John'
   };
-  
+
   smiled = false;
 }
 
@@ -460,11 +525,11 @@ class HostComponentTester extends ComponentTester<HostComponent> {
   constructor() {
     super(HostComponent);
   }
-  
+
   get userComponent() {
     return this.component(UserComponent);
   }
-  
+
   // ...
 }
 ```
@@ -485,7 +550,7 @@ But you still need to call `detectChanges()` by yourself in the other cases:
   `detectChanges()`. You need to do it yourself. The first call will cause the component lifecycle to start,
   just as when using a `ComponentFixture` directly.
 - to force change detection once you've changed the state of your component without dispatching an event:
-  by changing the state, or emitting an event through a subject, or triggering a navigation 
+  by changing the state, or emitting an event through a subject, or triggering a navigation
   from the `ActivatedRouteStub`
 
 ### Can I use the `TestElement` methods to act on the component element itself, rather than a sub-element?

package/esm2022/lib/component-tester.mjs

@@ -143,5 +143,12 @@ export class ComponentTester {
     detectChanges(checkNoChanges) {
         this.fixture.detectChanges(checkNoChanges);
     }
+    /**
+     * Delegates to the wrapped fixture whenStable and then detect changes
+     */
+    async stable() {
+        await this.fixture.whenStable();
+        this.detectChanges();
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-tester.js","sourceRoot":"","sources":["../../../../projects/ngx-speculoos/src/lib/component-tester.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { ComponentFixture, TestBed } from '@angular/core/testing';\nimport { DebugElement, ProviderToken, Type } from '@angular/core';\nimport { TestTextArea } from './test-textarea';\nimport { TestElement } from './test-element';\nimport { TestInput } from './test-input';\nimport { TestSelect } from './test-select';\nimport { TestButton } from './test-button';\nimport { TestElementQuerier } from './test-element-querier';\nimport { TestHtmlElement } from './test-html-element';\n\n/**\n * The main entry point of the API. It wraps an Angular ComponentFixture<T>, and gives access to its\n * most used properties and methods. It also allows getting elements wrapped in TestElement (and its subclasses)\n * @param <C> the type of the component to test\n */\nexport class ComponentTester<C> {\n  /**\n   * The test element of the component\n   */\n  readonly testElement: TestElement<HTMLElement>;\n\n  /**\n   * The component fixture of the component\n   */\n  readonly fixture: ComponentFixture<C>;\n\n  /**\n   * Creates a component fixture of the given type with the TestBed and wraps it into a ComponentTester\n   */\n  static create<C>(componentType: Type<C>): ComponentTester<C> {\n    const fixture = TestBed.createComponent(componentType);\n    return new ComponentTester(fixture);\n  }\n\n  /**\n   * Creates a ComponentFixture for the given component type using the TestBed, and creates a ComponentTester\n   * wrapping (and delegating) to this fixture. If a fixture is passed, then delegates to this fixture directly.\n   *\n   * Note that no `detectChanges()` call is made by this constructor. It's up to the subclass constructor,\n   * or to the user of the created ComponentTester, to call `detectChanges()` at least once to trigger change\n   * detection. This is necessary because some component templates can only be evaluated once inputs\n   * have been set on the component instance.\n   *\n   * @param arg the type of the component to wrap, or a component fixture to wrap\n   */\n  constructor(arg: Type<C> | ComponentFixture<C>) {\n    this.fixture = arg instanceof ComponentFixture ? arg : TestBed.createComponent(arg);\n    this.testElement = TestElementQuerier.wrap(this.debugElement, this) as TestElement<HTMLElement>;\n  }\n\n  /**\n   * The native DOM host element of the component\n   */\n  get nativeElement(): HTMLElement {\n    return this.fixture.nativeElement;\n  }\n\n  /**\n   * Gets the instance of the tested component from the wrapped fixture\n   */\n  get componentInstance(): C {\n    return this.fixture.componentInstance;\n  }\n\n  /**\n   * Gets the debug element from the wrapped fixture\n   */\n  get debugElement(): DebugElement {\n    return this.fixture.debugElement;\n  }\n\n  /**\n   * Gets the first element matching the given CSS selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestHtmlElement&lt;HTMLDivElement> | null = tester.element('div');\n   * </code>\n   * @param selector a CSS selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<K extends keyof HTMLElementTagNameMap>(selector: K): TestHtmlElement<HTMLElementTagNameMap[K]> | null;\n  /**\n   * Gets the first element matching the given CSS selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestElement&lt;SVGLineElement> | null = tester.element('line');\n   * </code>\n   * @param selector a CSS selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<K extends keyof SVGElementTagNameMap>(selector: K): TestElement<SVGElementTagNameMap[K]> | null;\n  /**\n   * Gets the first element matching the given CSS selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestElement | null = tester.element('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element(selector: string | Type<any>): TestElement | null;\n  /**\n   * Gets the first element matching the given selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestInput | null = tester.element&lt;HTMLInputElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<T extends HTMLInputElement>(selector: string | Type<any>): TestInput | null;\n  /**\n   * Gets the first element matching the given selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestTextArea | null = tester.element&lt;HTMLTextAreaElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<T extends HTMLTextAreaElement>(selector: string | Type<any>): TestTextArea | null;\n  /**\n   * Gets the first element matching the given selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestSelect | null = tester.element&lt;HTMLSelectElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<T extends HTMLSelectElement>(selector: string | Type<any>): TestSelect | null;\n  /**\n   * Gets the first element matching the given selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestButton | null = tester.element&lt;HTMLButtonElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<T extends HTMLButtonElement>(selector: string | Type<any>): TestButton | null;\n  /**\n   * Gets the first element matching the given selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestHtmlElement&lt;HTMLDivElement> | null = tester.element&lt;HTMLDivElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<T extends HTMLElement>(selector: string | Type<any>): TestHtmlElement<T> | null;\n  /**\n   * Gets the first element matching the given selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestElement&lt;SVGLineElement> | null = tester.element&lt;SVGLineElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<T extends Element>(selector: string | Type<any>): TestElement<T> | null;\n  element(selector: string | Type<any>): TestElement | null {\n    return this.testElement.element(selector);\n  }\n\n  /**\n   * Gets all the elements matching the given CSS selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestHtmlElement&lt;HTMLDivElement>> = tester.elements('div');\n   * </code>\n   * @param selector a CSS selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<K extends keyof HTMLElementTagNameMap>(selector: K): Array<TestHtmlElement<HTMLElementTagNameMap[K]>>;\n  /**\n   * Gets all the elements matching the given CSS selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestElement&lt;SVGLineElement>> = tester.elements('line');\n   * </code>\n   * @param selector a CSS selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<K extends keyof SVGElementTagNameMap>(selector: K): Array<TestElement<SVGElementTagNameMap[K]>>;\n  /**\n   * Gets all the elements matching the given selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestElement> = tester.elements('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements(selector: string | Type<any>): Array<TestElement>;\n  /**\n   * Gets all the elements matching the given selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestInput> = tester.elements&lt;HTMLInputElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<T extends HTMLInputElement>(selector: string | Type<any>): Array<TestInput>;\n  /**\n   * Gets all the elements matching the given selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestTextArea> = tester.elements&lt;HTMLTextAreaElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<T extends HTMLTextAreaElement>(selector: string | Type<any>): Array<TestTextArea>;\n  /**\n   * Gets all the elements matching the given CSS selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestButton> = tester.elements&lt;HTMLButtonElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<T extends HTMLButtonElement>(selector: string | Type<any>): Array<TestButton>;\n  /**\n   * Gets all the elements matching the given selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestSelect> = tester.elements<HTMLSelectElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<T extends HTMLSelectElement>(selector: string | Type<any>): Array<TestSelect>;\n  /**\n   * Gets all the elements matching the given selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestHtmlElement&lt;HTMLDivElement>> = tester.elements&lt;HTMLDivElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<T extends HTMLElement>(selector: string | Type<any>): Array<TestHtmlElement<T>>;\n  /**\n   * Gets all the elements matching the given selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestElement&lt;SVGLineElement>> = tester.elements&lt;SVGLineElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<T extends Element>(selector: string | Type<any>): Array<TestElement<T>>;\n  elements(selector: string | Type<any>): Array<TestElement> {\n    return this.testElement.elements(selector);\n  }\n\n  /**\n   * Gets the first input matched by the given selector. Throws an Error if the matched element isn't actually an input.\n   * @param selector a CSS or directive selector\n   * @returns the wrapped input, or null if no element was matched\n   */\n  input(selector: string | Type<any>): TestInput | null {\n    return this.testElement.input(selector);\n  }\n\n  /**\n   * Gets the first select matched by the given selector. Throws an Error if the matched element isn't actually a select.\n   * @param selector a CSS or directive selector\n   * @returns the wrapped select, or null if no element was matched\n   */\n  select(selector: string | Type<any>): TestSelect | null {\n    return this.testElement.select(selector);\n  }\n\n  /**\n   * Gets the first textarea matched by the given selector\n   * @param selector a CSS or directive selector\n   * @returns the wrapped textarea, or null if no element was matched. Throws an Error if the matched element isn't actually a textarea.\n   * @throws {Error} if the matched element isn't actually a textarea\n   */\n  textarea(selector: string | Type<any>): TestTextArea | null {\n    return this.testElement.textarea(selector);\n  }\n\n  /**\n   * Gets the first button matched by the given selector. Throws an Error if the matched element isn't actually a button.\n   * @param selector a CSS or directive selector\n   * @returns the wrapped button, or null if no element was matched\n   */\n  button(selector: string | Type<any>): TestButton | null {\n    return this.testElement.button(selector);\n  }\n\n  /**\n   * Gets the first directive matching the given component directive selector and returns its component instance\n   * @param selector the selector of a component directive\n   */\n  component<R>(selector: Type<R>): R {\n    return this.testElement.component(selector);\n  }\n\n  /**\n   * Gets the directives matching the given component directive selector and returns their component instance\n   * @param selector the selector of a component directive\n   */\n  components<R>(selector: Type<R>): Array<R> {\n    return this.testElement.components(selector);\n  }\n\n  /**\n   * Gets the first element matching the given selector, then gets the given token from its injector, or null if there is no such token\n   * @param selector a CSS or directive selector\n   * @param token the token to get from the matched element injector\n   */\n  token<R>(selector: string | Type<any>, token: ProviderToken<R>): R | null {\n    return this.testElement.token(selector, token);\n  }\n\n  /**\n   * Gets the elements matching the given selector, then gets their given token from their injector, or null if there is no such token\n   * @param selector a CSS or directive selector\n   * @param token the token to get from the matched element injector\n   */\n  tokens<R>(selector: string | Type<any>, token: ProviderToken<R>): Array<R | null> {\n    return this.testElement.tokens(selector, token);\n  }\n\n  /**\n   * Gets the element matching the given selector, and if found, creates and returns a custom TestElement of the provided\n   * type. This is useful to create custom higher-level abstractions similar to TestInput, TestSelect, etc. for\n   * custom elements or components.\n   * @param selector a CSS or directive selector\n   * @param customTestElementType the type of the TestElement subclass that will wrap the found element\n   */\n  custom<E extends TestElement>(selector: string | Type<any>, customTestElementType: Type<E>): E | null {\n    return this.testElement.custom(selector, customTestElementType);\n  }\n\n  /**\n   * Gets the elements matching the given selector, and creates and returns custom TestElements of the provided\n   * type. This is useful to create custom higher-level abstractions similar to TestInput, TestSelect, etc. for\n   * custom elements or components.\n   * @param selector a CSS or directive selector\n   * @param customTestElementType the type of the TestElement subclass that will wrap the found elements\n   */\n  customs<E extends TestElement>(selector: string | Type<any>, customTestElementType: Type<E>): Array<E> {\n    return this.testElement.customs(selector, customTestElementType);\n  }\n\n  /**\n   * Triggers a change detection using the wrapped fixture\n   */\n  detectChanges(checkNoChanges?: boolean): void {\n    this.fixture.detectChanges(checkNoChanges);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-tester.js","sourceRoot":"","sources":["../../../../projects/ngx-speculoos/src/lib/component-tester.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { ComponentFixture, TestBed } from '@angular/core/testing';\nimport { DebugElement, ProviderToken, Type } from '@angular/core';\nimport { TestTextArea } from './test-textarea';\nimport { TestElement } from './test-element';\nimport { TestInput } from './test-input';\nimport { TestSelect } from './test-select';\nimport { TestButton } from './test-button';\nimport { TestElementQuerier } from './test-element-querier';\nimport { TestHtmlElement } from './test-html-element';\n\n/**\n * The main entry point of the API. It wraps an Angular ComponentFixture<T>, and gives access to its\n * most used properties and methods. It also allows getting elements wrapped in TestElement (and its subclasses)\n * @param <C> the type of the component to test\n */\nexport class ComponentTester<C> {\n  /**\n   * The test element of the component\n   */\n  readonly testElement: TestElement<HTMLElement>;\n\n  /**\n   * The component fixture of the component\n   */\n  readonly fixture: ComponentFixture<C>;\n\n  /**\n   * Creates a component fixture of the given type with the TestBed and wraps it into a ComponentTester\n   */\n  static create<C>(componentType: Type<C>): ComponentTester<C> {\n    const fixture = TestBed.createComponent(componentType);\n    return new ComponentTester(fixture);\n  }\n\n  /**\n   * Creates a ComponentFixture for the given component type using the TestBed, and creates a ComponentTester\n   * wrapping (and delegating) to this fixture. If a fixture is passed, then delegates to this fixture directly.\n   *\n   * Note that no `detectChanges()` call is made by this constructor. It's up to the subclass constructor,\n   * or to the user of the created ComponentTester, to call `detectChanges()` at least once to trigger change\n   * detection. This is necessary because some component templates can only be evaluated once inputs\n   * have been set on the component instance.\n   *\n   * @param arg the type of the component to wrap, or a component fixture to wrap\n   */\n  constructor(arg: Type<C> | ComponentFixture<C>) {\n    this.fixture = arg instanceof ComponentFixture ? arg : TestBed.createComponent(arg);\n    this.testElement = TestElementQuerier.wrap(this.debugElement, this) as TestElement<HTMLElement>;\n  }\n\n  /**\n   * The native DOM host element of the component\n   */\n  get nativeElement(): HTMLElement {\n    return this.fixture.nativeElement;\n  }\n\n  /**\n   * Gets the instance of the tested component from the wrapped fixture\n   */\n  get componentInstance(): C {\n    return this.fixture.componentInstance;\n  }\n\n  /**\n   * Gets the debug element from the wrapped fixture\n   */\n  get debugElement(): DebugElement {\n    return this.fixture.debugElement;\n  }\n\n  /**\n   * Gets the first element matching the given CSS selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestHtmlElement&lt;HTMLDivElement> | null = tester.element('div');\n   * </code>\n   * @param selector a CSS selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<K extends keyof HTMLElementTagNameMap>(selector: K): TestHtmlElement<HTMLElementTagNameMap[K]> | null;\n  /**\n   * Gets the first element matching the given CSS selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestElement&lt;SVGLineElement> | null = tester.element('line');\n   * </code>\n   * @param selector a CSS selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<K extends keyof SVGElementTagNameMap>(selector: K): TestElement<SVGElementTagNameMap[K]> | null;\n  /**\n   * Gets the first element matching the given CSS selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestElement | null = tester.element('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element(selector: string | Type<any>): TestElement | null;\n  /**\n   * Gets the first element matching the given selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestInput | null = tester.element&lt;HTMLInputElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<T extends HTMLInputElement>(selector: string | Type<any>): TestInput | null;\n  /**\n   * Gets the first element matching the given selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestTextArea | null = tester.element&lt;HTMLTextAreaElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<T extends HTMLTextAreaElement>(selector: string | Type<any>): TestTextArea | null;\n  /**\n   * Gets the first element matching the given selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestSelect | null = tester.element&lt;HTMLSelectElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<T extends HTMLSelectElement>(selector: string | Type<any>): TestSelect | null;\n  /**\n   * Gets the first element matching the given selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestButton | null = tester.element&lt;HTMLButtonElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<T extends HTMLButtonElement>(selector: string | Type<any>): TestButton | null;\n  /**\n   * Gets the first element matching the given selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestHtmlElement&lt;HTMLDivElement> | null = tester.element&lt;HTMLDivElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<T extends HTMLElement>(selector: string | Type<any>): TestHtmlElement<T> | null;\n  /**\n   * Gets the first element matching the given selector and wraps it into a TestElement. The actual type\n   * of the returned value is the TestElement subclass matching the type of the found element. So, if the\n   * matched element is an input for example, the method will return a TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElement: TestElement&lt;SVGLineElement> | null = tester.element&lt;SVGLineElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the wrapped element, or null if no element matches the selector.\n   */\n  element<T extends Element>(selector: string | Type<any>): TestElement<T> | null;\n  element(selector: string | Type<any>): TestElement | null {\n    return this.testElement.element(selector);\n  }\n\n  /**\n   * Gets all the elements matching the given CSS selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestHtmlElement&lt;HTMLDivElement>> = tester.elements('div');\n   * </code>\n   * @param selector a CSS selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<K extends keyof HTMLElementTagNameMap>(selector: K): Array<TestHtmlElement<HTMLElementTagNameMap[K]>>;\n  /**\n   * Gets all the elements matching the given CSS selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestElement&lt;SVGLineElement>> = tester.elements('line');\n   * </code>\n   * @param selector a CSS selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<K extends keyof SVGElementTagNameMap>(selector: K): Array<TestElement<SVGElementTagNameMap[K]>>;\n  /**\n   * Gets all the elements matching the given selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestElement> = tester.elements('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements(selector: string | Type<any>): Array<TestElement>;\n  /**\n   * Gets all the elements matching the given selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestInput> = tester.elements&lt;HTMLInputElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<T extends HTMLInputElement>(selector: string | Type<any>): Array<TestInput>;\n  /**\n   * Gets all the elements matching the given selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestTextArea> = tester.elements&lt;HTMLTextAreaElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<T extends HTMLTextAreaElement>(selector: string | Type<any>): Array<TestTextArea>;\n  /**\n   * Gets all the elements matching the given CSS selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestButton> = tester.elements&lt;HTMLButtonElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<T extends HTMLButtonElement>(selector: string | Type<any>): Array<TestButton>;\n  /**\n   * Gets all the elements matching the given selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestSelect> = tester.elements<HTMLSelectElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<T extends HTMLSelectElement>(selector: string | Type<any>): Array<TestSelect>;\n  /**\n   * Gets all the elements matching the given selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestHtmlElement&lt;HTMLDivElement>> = tester.elements&lt;HTMLDivElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<T extends HTMLElement>(selector: string | Type<any>): Array<TestHtmlElement<T>>;\n  /**\n   * Gets all the elements matching the given selector and wraps them into a TestElement. The actual type\n   * of the returned elements is the TestElement subclass matching the type of the found element. So, if the\n   * matched elements are inputs for example, the method will return an array of TestInput.\n   * <p>Usage:</p>\n   * <code>\n   * const testElements: Array&lt;TestElement&lt;SVGLineElement>> = tester.elements&lt;SVGLineElement>('.selector');\n   * </code>\n   * @param selector a CSS or directive selector\n   * @returns the array of matched elements, empty if no element was matched\n   */\n  elements<T extends Element>(selector: string | Type<any>): Array<TestElement<T>>;\n  elements(selector: string | Type<any>): Array<TestElement> {\n    return this.testElement.elements(selector);\n  }\n\n  /**\n   * Gets the first input matched by the given selector. Throws an Error if the matched element isn't actually an input.\n   * @param selector a CSS or directive selector\n   * @returns the wrapped input, or null if no element was matched\n   */\n  input(selector: string | Type<any>): TestInput | null {\n    return this.testElement.input(selector);\n  }\n\n  /**\n   * Gets the first select matched by the given selector. Throws an Error if the matched element isn't actually a select.\n   * @param selector a CSS or directive selector\n   * @returns the wrapped select, or null if no element was matched\n   */\n  select(selector: string | Type<any>): TestSelect | null {\n    return this.testElement.select(selector);\n  }\n\n  /**\n   * Gets the first textarea matched by the given selector\n   * @param selector a CSS or directive selector\n   * @returns the wrapped textarea, or null if no element was matched. Throws an Error if the matched element isn't actually a textarea.\n   * @throws {Error} if the matched element isn't actually a textarea\n   */\n  textarea(selector: string | Type<any>): TestTextArea | null {\n    return this.testElement.textarea(selector);\n  }\n\n  /**\n   * Gets the first button matched by the given selector. Throws an Error if the matched element isn't actually a button.\n   * @param selector a CSS or directive selector\n   * @returns the wrapped button, or null if no element was matched\n   */\n  button(selector: string | Type<any>): TestButton | null {\n    return this.testElement.button(selector);\n  }\n\n  /**\n   * Gets the first directive matching the given component directive selector and returns its component instance\n   * @param selector the selector of a component directive\n   */\n  component<R>(selector: Type<R>): R {\n    return this.testElement.component(selector);\n  }\n\n  /**\n   * Gets the directives matching the given component directive selector and returns their component instance\n   * @param selector the selector of a component directive\n   */\n  components<R>(selector: Type<R>): Array<R> {\n    return this.testElement.components(selector);\n  }\n\n  /**\n   * Gets the first element matching the given selector, then gets the given token from its injector, or null if there is no such token\n   * @param selector a CSS or directive selector\n   * @param token the token to get from the matched element injector\n   */\n  token<R>(selector: string | Type<any>, token: ProviderToken<R>): R | null {\n    return this.testElement.token(selector, token);\n  }\n\n  /**\n   * Gets the elements matching the given selector, then gets their given token from their injector, or null if there is no such token\n   * @param selector a CSS or directive selector\n   * @param token the token to get from the matched element injector\n   */\n  tokens<R>(selector: string | Type<any>, token: ProviderToken<R>): Array<R | null> {\n    return this.testElement.tokens(selector, token);\n  }\n\n  /**\n   * Gets the element matching the given selector, and if found, creates and returns a custom TestElement of the provided\n   * type. This is useful to create custom higher-level abstractions similar to TestInput, TestSelect, etc. for\n   * custom elements or components.\n   * @param selector a CSS or directive selector\n   * @param customTestElementType the type of the TestElement subclass that will wrap the found element\n   */\n  custom<E extends TestElement>(selector: string | Type<any>, customTestElementType: Type<E>): E | null {\n    return this.testElement.custom(selector, customTestElementType);\n  }\n\n  /**\n   * Gets the elements matching the given selector, and creates and returns custom TestElements of the provided\n   * type. This is useful to create custom higher-level abstractions similar to TestInput, TestSelect, etc. for\n   * custom elements or components.\n   * @param selector a CSS or directive selector\n   * @param customTestElementType the type of the TestElement subclass that will wrap the found elements\n   */\n  customs<E extends TestElement>(selector: string | Type<any>, customTestElementType: Type<E>): Array<E> {\n    return this.testElement.customs(selector, customTestElementType);\n  }\n\n  /**\n   * Triggers a change detection using the wrapped fixture\n   */\n  detectChanges(checkNoChanges?: boolean): void {\n    this.fixture.detectChanges(checkNoChanges);\n  }\n\n  /**\n   * Delegates to the wrapped fixture whenStable and then detect changes\n   */\n  async stable(): Promise<void> {\n    await this.fixture.whenStable();\n    this.detectChanges();\n  }\n}\n"]}

package/esm2022/lib/matchers.mjs

@@ -280,4 +280,4 @@ const speculoosMatchers = {
     }
 };
 export { speculoosMatchers };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matchers.js","sourceRoot":"","sources":["../../../../projects/ngx-speculoos/src/lib/matchers.ts"],"names":[],"mappings":"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","sourcesContent":["import { TestTextArea } from './test-textarea';\nimport { TestInput } from './test-input';\nimport { TestElement } from './test-element';\nimport { TestSelect } from './test-select';\nimport { TestHtmlElement } from './test-html-element';\n\nconst speculoosMatchers: jasmine.CustomMatcherFactories = {\n  /**\n   * Checks that the receiver is a TestElement wrapping a DOM element and as the given CSS class\n   */\n  toHaveClass(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: string) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check class '${expected}' on element, but element was falsy` };\n      }\n      if (!(el instanceof TestElement)) {\n        return { pass: false, message: `Expected to check class '${expected}' on element, but element was not a TestElement` };\n      }\n      const actual = el.classes;\n      const pass = actual.indexOf(expected) !== -1;\n      const message =\n        `Expected element to ${isNegative ? 'not ' : ''}have class '${expected}', ` +\n        `but had ${actual.length ? \"'\" + actual.join(', ') + \"'\" : 'none'}`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestInput or a TestTextArea and has the given value\n   */\n  toHaveValue(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: string) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check value '${expected}' on element, but element was falsy` };\n      }\n      if (!(el instanceof TestInput) && !(el instanceof TestTextArea)) {\n        return {\n          pass: false,\n          message: `Expected to check value '${expected}' on element, but element was neither a TestInput nor a TestTextArea`\n        };\n      }\n      const actual = el.value;\n      const pass = actual === expected;\n      const message = `Expected element to ${isNegative ? 'not ' : ''}have value '${expected}', but had value '${actual}'`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestElement wrapping a DOM element and has the exact given textContent\n   */\n  toHaveText(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: string) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check text '${expected}' on element, but element was falsy` };\n      }\n      if (!(el instanceof TestElement)) {\n        return { pass: false, message: `Expected to check text '${expected}' on element, but element was not a TestElement` };\n      }\n      const actual = el.textContent;\n      const pass = actual === expected;\n      const message = `Expected element to ${isNegative ? 'not ' : ''}have text '${expected}', but had '${actual}'`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestElement wrapping a DOM element and has the given textContent, after both have been trimmed.\n   * So, An element such as\n   * ```\n   * <h1>\n   *   Some title\n   * </h1>\n   * ```\n   * will pass the test\n   * ```\n   * expect(tester.title).toHaveTrimmedText('Some title')\n   * ```\n   */\n  toHaveTrimmedText(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: string) => {\n      const trimmedExpected = expected.trim();\n      if (!el) {\n        return { pass: false, message: `Expected to check trimmed text '${trimmedExpected}' on element, but element was falsy` };\n      }\n      if (!(el instanceof TestElement)) {\n        return {\n          pass: false,\n          message: `Expected to check trimmed text '${trimmedExpected}' on element, but element was not a TestElement`\n        };\n      }\n      const actual = el.textContent?.trim();\n      const pass = actual === trimmedExpected;\n      const message = `Expected element to ${isNegative ? 'not ' : ''}have trimmed text '${trimmedExpected}', but had '${actual}'`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestElement wrapping a DOM element and contains the given textContent\n   */\n  toContainText(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: string) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check text '${expected}' on element, but element was falsy` };\n      }\n      if (!(el instanceof TestElement)) {\n        return { pass: false, message: `Expected to check text '${expected}' on element, but element was not a TestElement` };\n      }\n      const actual = el.textContent;\n      if (!actual) {\n        return {\n          pass: isNegative,\n          message: `Expected element to ${isNegative ? 'not ' : ''}contain text '${expected}', but had no text`\n        };\n      }\n      const pass = actual.indexOf(expected) !== -1;\n      const message = `Expected element to ${isNegative ? 'not ' : ''}contain text '${expected}', but had text '${actual}'`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestElement wrapping a DOM element and contains the given textContent\n   */\n  toBeChecked(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check if element was checked, but element was falsy` };\n      }\n      if (!(el instanceof TestInput)) {\n        return { pass: false, message: `Expected to check if element was checked, but element was not a TestInput` };\n      }\n      const pass = el.checked;\n      const message = `Expected element to be ${isNegative ? 'not ' : ''}checked, but was${!isNegative ? ' not' : ''}`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown): jasmine.CustomMatcherResult {\n        return assert(false, el);\n      },\n      negativeCompare(el: unknown): jasmine.CustomMatcherResult {\n        return assert(true, el);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestSelect wrapping a DOM element and has the given selected index\n   */\n  toHaveSelectedIndex(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: number) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check selected index ${expected} on element, but element was falsy` };\n      }\n      if (!(el instanceof TestSelect)) {\n        return { pass: false, message: `Expected to check selected index ${expected} on element, but element was not a TestSelect` };\n      }\n      const actual = el.selectedIndex;\n      const pass = actual === expected;\n      const message = `Expected element to ${isNegative ? 'not ' : ''}have selected index ${expected}, but had ${actual}`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: number): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: number): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestSelect wrapping a DOM element with the selected option's value equal to the given value\n   */\n  toHaveSelectedValue(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: string) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check selected value '${expected}' on element, but element was falsy` };\n      }\n      if (!(el instanceof TestSelect)) {\n        return { pass: false, message: `Expected to check selected value '${expected}' on element, but element was not a TestSelect` };\n      }\n      const actual = el.selectedValue;\n      const pass = actual === expected;\n      const message = `Expected element to ${isNegative ? 'not ' : ''}have selected value '${expected}', but had '${actual}'`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestSelect wrapping a DOM element with the selected option's label equal to the given label\n   */\n  toHaveSelectedLabel(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: string) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check selected label '${expected}' on element, but element was falsy` };\n      }\n      if (!(el instanceof TestSelect)) {\n        return { pass: false, message: `Expected to check selected label '${expected}' on element, but element was not a TestSelect` };\n      }\n      const actual = el.selectedLabel;\n      const pass = actual === expected;\n      const message = `Expected element to ${isNegative ? 'not ' : ''}have selected label '${expected}', but had '${actual}'`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestHtmlElement which is visible\n   */\n  toBeVisible(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown) => {\n      const expectedState = `${isNegative ? 'in' : ''}visible`;\n      const inverseState = `${isNegative ? '' : 'in'}visible`;\n      if (!el) {\n        return { pass: false, message: `Expected to check if element was ${expectedState}, but element was falsy` };\n      }\n      if (!(el instanceof TestHtmlElement)) {\n        return { pass: false, message: `Expected to check if element was ${expectedState}, but element was not a TestHtmlElement` };\n      }\n      const pass = el.visible;\n      const message = `Expected element to be ${expectedState}, but was ${inverseState}`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown): jasmine.CustomMatcherResult {\n        return assert(false, el);\n      },\n      negativeCompare(el: unknown): jasmine.CustomMatcherResult {\n        return assert(true, el);\n      }\n    };\n  }\n};\n\nexport { speculoosMatchers };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matchers.js","sourceRoot":"","sources":["../../../../projects/ngx-speculoos/src/lib/matchers.ts"],"names":[],"mappings":"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","sourcesContent":["import { TestTextArea } from './test-textarea';\nimport { TestInput } from './test-input';\nimport { TestElement } from './test-element';\nimport { TestSelect } from './test-select';\nimport { TestHtmlElement } from './test-html-element';\n\nconst speculoosMatchers: jasmine.CustomMatcherFactories = {\n  /**\n   * Checks that the receiver is a TestElement wrapping a DOM element and as the given CSS class\n   */\n  toHaveClass(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: string) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check class '${expected}' on element, but element was falsy` };\n      }\n      if (!(el instanceof TestElement)) {\n        return { pass: false, message: `Expected to check class '${expected}' on element, but element was not a TestElement` };\n      }\n      const actual = el.classes;\n      const pass = actual.indexOf(expected) !== -1;\n      const message =\n        `Expected element to ${isNegative ? 'not ' : ''}have class '${expected}', ` +\n        `but had ${actual.length ? \"'\" + actual.join(', ') + \"'\" : 'none'}`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestInput or a TestTextArea and has the given value\n   */\n  toHaveValue(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: string) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check value '${expected}' on element, but element was falsy` };\n      }\n      if (!(el instanceof TestInput) && !(el instanceof TestTextArea)) {\n        return {\n          pass: false,\n          message: `Expected to check value '${expected}' on element, but element was neither a TestInput nor a TestTextArea`\n        };\n      }\n      const actual = el.value;\n      const pass = actual === expected;\n      const message = `Expected element to ${isNegative ? 'not ' : ''}have value '${expected}', but had value '${actual}'`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestElement wrapping a DOM element and has the exact given textContent\n   */\n  toHaveText(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: string) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check text '${expected}' on element, but element was falsy` };\n      }\n      if (!(el instanceof TestElement)) {\n        return { pass: false, message: `Expected to check text '${expected}' on element, but element was not a TestElement` };\n      }\n      const actual = el.textContent;\n      const pass = actual === expected;\n      const message = `Expected element to ${isNegative ? 'not ' : ''}have text '${expected}', but had '${actual}'`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestElement wrapping a DOM element and has the given textContent, after both have been trimmed.\n   * So, An element such as\n   * ```\n   * <h1>\n   *   Some title\n   * </h1>\n   * ```\n   * will pass the test\n   * ```\n   * expect(tester.title).toHaveTrimmedText('Some title')\n   * ```\n   */\n  toHaveTrimmedText(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: string) => {\n      const trimmedExpected = expected.trim();\n      if (!el) {\n        return { pass: false, message: `Expected to check trimmed text '${trimmedExpected}' on element, but element was falsy` };\n      }\n      if (!(el instanceof TestElement)) {\n        return {\n          pass: false,\n          message: `Expected to check trimmed text '${trimmedExpected}' on element, but element was not a TestElement`\n        };\n      }\n      const actual = el.textContent?.trim();\n      const pass = actual === trimmedExpected;\n      const message = `Expected element to ${isNegative ? 'not ' : ''}have trimmed text '${trimmedExpected}', but had '${actual}'`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestElement wrapping a DOM element and contains the given textContent\n   */\n  toContainText(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: string) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check text '${expected}' on element, but element was falsy` };\n      }\n      if (!(el instanceof TestElement)) {\n        return { pass: false, message: `Expected to check text '${expected}' on element, but element was not a TestElement` };\n      }\n      const actual = el.textContent;\n      if (!actual) {\n        return {\n          pass: isNegative,\n          message: `Expected element to ${isNegative ? 'not ' : ''}contain text '${expected}', but had no text`\n        };\n      }\n      const pass = actual.indexOf(expected) !== -1;\n      const message = `Expected element to ${isNegative ? 'not ' : ''}contain text '${expected}', but had text '${actual}'`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestElement wrapping a DOM element and contains the given textContent\n   */\n  toBeChecked(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check if element was checked, but element was falsy` };\n      }\n      if (!(el instanceof TestInput)) {\n        return { pass: false, message: `Expected to check if element was checked, but element was not a TestInput` };\n      }\n      const pass = el.checked;\n      const message = `Expected element to be ${isNegative ? 'not ' : ''}checked, but was${!isNegative ? ' not' : ''}`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown): jasmine.CustomMatcherResult {\n        return assert(false, el);\n      },\n      negativeCompare(el: unknown): jasmine.CustomMatcherResult {\n        return assert(true, el);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestSelect wrapping a DOM element and has the given selected index\n   */\n  toHaveSelectedIndex(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: number) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check selected index ${expected} on element, but element was falsy` };\n      }\n      if (!(el instanceof TestSelect)) {\n        return { pass: false, message: `Expected to check selected index ${expected} on element, but element was not a TestSelect` };\n      }\n      const actual = el.selectedIndex;\n      const pass = actual === expected;\n      const message = `Expected element to ${isNegative ? 'not ' : ''}have selected index ${expected}, but had ${actual}`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: number): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: number): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestSelect wrapping a DOM element with the selected option's value equal to the given value\n   */\n  toHaveSelectedValue(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: string) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check selected value '${expected}' on element, but element was falsy` };\n      }\n      if (!(el instanceof TestSelect)) {\n        return { pass: false, message: `Expected to check selected value '${expected}' on element, but element was not a TestSelect` };\n      }\n      const actual = el.selectedValue;\n      const pass = actual === expected;\n      const message = `Expected element to ${isNegative ? 'not ' : ''}have selected value '${expected}', but had '${actual}'`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestSelect wrapping a DOM element with the selected option's label equal to the given label\n   */\n  toHaveSelectedLabel(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown, expected: string) => {\n      if (!el) {\n        return { pass: false, message: `Expected to check selected label '${expected}' on element, but element was falsy` };\n      }\n      if (!(el instanceof TestSelect)) {\n        return { pass: false, message: `Expected to check selected label '${expected}' on element, but element was not a TestSelect` };\n      }\n      const actual = el.selectedLabel;\n      const pass = actual === expected;\n      const message = `Expected element to ${isNegative ? 'not ' : ''}have selected label '${expected}', but had '${actual}'`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(false, el, expected);\n      },\n      negativeCompare(el: unknown, expected: string): jasmine.CustomMatcherResult {\n        return assert(true, el, expected);\n      }\n    };\n  },\n\n  /**\n   * Checks that the receiver is a TestHtmlElement which is visible\n   */\n  toBeVisible(): jasmine.CustomMatcher {\n    const assert = (isNegative: boolean, el: unknown) => {\n      const expectedState = `${isNegative ? 'in' : ''}visible`;\n      const inverseState = `${isNegative ? '' : 'in'}visible`;\n      if (!el) {\n        return { pass: false, message: `Expected to check if element was ${expectedState}, but element was falsy` };\n      }\n      if (!(el instanceof TestHtmlElement)) {\n        return { pass: false, message: `Expected to check if element was ${expectedState}, but element was not a TestHtmlElement` };\n      }\n      const pass = el.visible;\n      const message = `Expected element to be ${expectedState}, but was ${inverseState}`;\n      return { pass: isNegative ? !pass : pass, message };\n    };\n    return {\n      compare(el: unknown): jasmine.CustomMatcherResult {\n        return assert(false, el);\n      },\n      negativeCompare(el: unknown): jasmine.CustomMatcherResult {\n        return assert(true, el);\n      }\n    };\n  }\n};\n\nexport { speculoosMatchers };\n"]}

package/esm2022/lib/mock.mjs

@@ -22,4 +22,4 @@ function collectMethodNames(proto) {
 export function createMock(type) {
     return jasmine.createSpyObj(type.name, collectMethodNames(type.prototype));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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