ngx-speculoos 4.1.0 → 7.1.0

package/esm2020/jasmine-matchers.mjs

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/component-tester.mjs

@@ -0,0 +1,147 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { TestElementQuerier } from './test-element-querier';
+/**
+ * The main entry point of the API. It wraps an Angular ComponentFixture<T>, and gives access to its
+ * most used properties and methods. It also allows getting elements wrapped in TestElement (and its subclasses)
+ * @param <C> the type of the component to test
+ */
+export class ComponentTester {
+    /**
+     * Creates a ComponentFixture for the given component type using the TestBed, and creates a ComponentTester
+     * wrapping (and delegating) to this fixture. If a fixture is passed, then delegates to this fixture directly.
+     *
+     * Note that no `detectChanges()` call is made by this constructor. It's up to the subclass constructor,
+     * or to the user of the created ComponentTester, to call `detectChanges()` at least once to trigger change
+     * detection. This is necessary because some component templates can only be evaluated once inputs
+     * have been set on the component instance.
+     *
+     * @param arg the type of the component to wrap, or a component fixture to wrap
+     */
+    constructor(arg) {
+        this.fixture = arg instanceof ComponentFixture ? arg : TestBed.createComponent(arg);
+        this.testElement = TestElementQuerier.wrap(this.debugElement, this);
+    }
+    /**
+     * Creates a component fixture of the given type with the TestBed and wraps it into a ComponentTester
+     */
+    static create(componentType) {
+        const fixture = TestBed.createComponent(componentType);
+        return new ComponentTester(fixture);
+    }
+    /**
+     * The native DOM host element of the component
+     */
+    get nativeElement() {
+        return this.fixture.nativeElement;
+    }
+    /**
+     * Gets the instance of the tested component from the wrapped fixture
+     */
+    get componentInstance() {
+        return this.fixture.componentInstance;
+    }
+    /**
+     * Gets the debug element from the wrapped fixture
+     */
+    get debugElement() {
+        return this.fixture.debugElement;
+    }
+    element(selector) {
+        return this.testElement.element(selector);
+    }
+    elements(selector) {
+        return this.testElement.elements(selector);
+    }
+    /**
+     * Gets the first input matched by the given selector. Throws an Error if the matched element isn't actually an input.
+     * @param selector a CSS or directive selector
+     * @returns the wrapped input, or null if no element was matched
+     */
+    input(selector) {
+        return this.testElement.input(selector);
+    }
+    /**
+     * Gets the first select matched by the given selector. Throws an Error if the matched element isn't actually a select.
+     * @param selector a CSS or directive selector
+     * @returns the wrapped select, or null if no element was matched
+     */
+    select(selector) {
+        return this.testElement.select(selector);
+    }
+    /**
+     * Gets the first textarea matched by the given selector
+     * @param selector a CSS or directive selector
+     * @returns the wrapped textarea, or null if no element was matched. Throws an Error if the matched element isn't actually a textarea.
+     * @throws {Error} if the matched element isn't actually a textarea
+     */
+    textarea(selector) {
+        return this.testElement.textarea(selector);
+    }
+    /**
+     * Gets the first button matched by the given selector. Throws an Error if the matched element isn't actually a button.
+     * @param selector a CSS or directive selector
+     * @returns the wrapped button, or null if no element was matched
+     */
+    button(selector) {
+        return this.testElement.button(selector);
+    }
+    /**
+     * Gets the first directive matching the given component directive selector and returns its component instance
+     * @param selector the selector of a component directive
+     */
+    component(selector) {
+        return this.testElement.component(selector);
+    }
+    /**
+     * Gets the directives matching the given component directive selector and returns their component instance
+     * @param selector the selector of a component directive
+     */
+    components(selector) {
+        return this.testElement.components(selector);
+    }
+    /**
+     * Gets the first element matching the given selector, then gets the given token from its injector, or null if there is no such token
+     * @param selector a CSS or directive selector
+     * @param token the token to get from the matched element injector
+     */
+    token(selector, token) {
+        return this.testElement.token(selector, token);
+    }
+    /**
+     * Gets the elements matching the given selector, then gets their given token from their injector, or null if there is no such token
+     * @param selector a CSS or directive selector
+     * @param token the token to get from the matched element injector
+     */
+    tokens(selector, token) {
+        return this.testElement.tokens(selector, token);
+    }
+    /**
+     * Gets the element matching the given selector, and if found, creates and returns a custom TestElement of the provided
+     * type. This is useful to create custom higher-level abstractions similar to TestInput, TestSelect, etc. for
+     * custom elements or components.
+     * @param selector a CSS or directive selector
+     * @param customTestElementType the type of the TestElement subclass that will wrap the found element
+     */
+    custom(selector, customTestElementType) {
+        return this.testElement.custom(selector, customTestElementType);
+    }
+    /**
+     * Gets the elements matching the given selector, and creates and returns custom TestElements of the provided
+     * type. This is useful to create custom higher-level abstractions similar to TestInput, TestSelect, etc. for
+     * custom elements or components.
+     * @param selector a CSS or directive selector
+     * @param customTestElementType the type of the TestElement subclass that will wrap the found elements
+     */
+    customs(selector, customTestElementType) {
+        return this.testElement.customs(selector, customTestElementType);
+    }
+    /**
+     * Triggers a change detection using the wrapped fixture
+     */
+    detectChanges(checkNoChanges) {
+        this.fixture.detectChanges(checkNoChanges);
+    }
+}
+//# 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"]}

package/esm2020/lib/matchers.mjs

@@ -0,0 +1,283 @@
+import { TestTextArea } from './test-textarea';
+import { TestInput } from './test-input';
+import { TestElement } from './test-element';
+import { TestSelect } from './test-select';
+import { TestHtmlElement } from './test-html-element';
+const speculoosMatchers = {
+    /**
+     * Checks that the receiver is a TestElement wrapping a DOM element and as the given CSS class
+     */
+    toHaveClass: () => {
+        const assert = (isNegative, el, expected) => {
+            if (!el) {
+                return { pass: false, message: `Expected to check class '${expected}' on element, but element was falsy` };
+            }
+            if (!(el instanceof TestElement)) {
+                return { pass: false, message: `Expected to check class '${expected}' on element, but element was not a TestElement` };
+            }
+            const actual = el.classes;
+            const pass = actual.indexOf(expected) !== -1;
+            const message = `Expected element to ${isNegative ? 'not ' : ''}have class '${expected}', ` +
+                `but had ${actual.length ? "'" + actual.join(', ') + "'" : 'none'}`;
+            return { pass: isNegative ? !pass : pass, message };
+        };
+        return {
+            compare: (el, expected) => {
+                return assert(false, el, expected);
+            },
+            negativeCompare: (el, expected) => {
+                return assert(true, el, expected);
+            }
+        };
+    },
+    /**
+     * Checks that the receiver is a TestInput or a TestTextArea and has the given value
+     */
+    toHaveValue: () => {
+        const assert = (isNegative, el, expected) => {
+            if (!el) {
+                return { pass: false, message: `Expected to check value '${expected}' on element, but element was falsy` };
+            }
+            if (!(el instanceof TestInput) && !(el instanceof TestTextArea)) {
+                return {
+                    pass: false,
+                    message: `Expected to check value '${expected}' on element, but element was neither a TestInput nor a TestTextArea`
+                };
+            }
+            const actual = el.value;
+            const pass = actual === expected;
+            const message = `Expected element to ${isNegative ? 'not ' : ''}have value '${expected}', but had value '${actual}'`;
+            return { pass: isNegative ? !pass : pass, message };
+        };
+        return {
+            compare: (el, expected) => {
+                return assert(false, el, expected);
+            },
+            negativeCompare: (el, expected) => {
+                return assert(true, el, expected);
+            }
+        };
+    },
+    /**
+     * Checks that the receiver is a TestElement wrapping a DOM element and has the exact given textContent
+     */
+    toHaveText: () => {
+        const assert = (isNegative, el, expected) => {
+            if (!el) {
+                return { pass: false, message: `Expected to check text '${expected}' on element, but element was falsy` };
+            }
+            if (!(el instanceof TestElement)) {
+                return { pass: false, message: `Expected to check text '${expected}' on element, but element was not a TestElement` };
+            }
+            const actual = el.textContent;
+            const pass = actual === expected;
+            const message = `Expected element to ${isNegative ? 'not ' : ''}have text '${expected}', but had '${actual}'`;
+            return { pass: isNegative ? !pass : pass, message };
+        };
+        return {
+            compare: (el, expected) => {
+                return assert(false, el, expected);
+            },
+            negativeCompare: (el, expected) => {
+                return assert(true, el, expected);
+            }
+        };
+    },
+    /**
+     * Checks that the receiver is a TestElement wrapping a DOM element and has the given textContent, after both have been trimmed.
+     * So, An element such as
+     * ```
+     * <h1>
+     *   Some title
+     * </h1>
+     * ```
+     * will pass the test
+     * ```
+     * expect(tester.title).toHaveTrimmedText('Some title')
+     * ```
+     */
+    toHaveTrimmedText: () => {
+        const assert = (isNegative, el, expected) => {
+            const trimmedExpected = expected.trim();
+            if (!el) {
+                return { pass: false, message: `Expected to check trimmed text '${trimmedExpected}' on element, but element was falsy` };
+            }
+            if (!(el instanceof TestElement)) {
+                return {
+                    pass: false,
+                    message: `Expected to check trimmed text '${trimmedExpected}' on element, but element was not a TestElement`
+                };
+            }
+            const actual = el.textContent?.trim();
+            const pass = actual === trimmedExpected;
+            const message = `Expected element to ${isNegative ? 'not ' : ''}have trimmed text '${trimmedExpected}', but had '${actual}'`;
+            return { pass: isNegative ? !pass : pass, message };
+        };
+        return {
+            compare: (el, expected) => {
+                return assert(false, el, expected);
+            },
+            negativeCompare: (el, expected) => {
+                return assert(true, el, expected);
+            }
+        };
+    },
+    /**
+     * Checks that the receiver is a TestElement wrapping a DOM element and contains the given textContent
+     */
+    toContainText: () => {
+        const assert = (isNegative, el, expected) => {
+            if (!el) {
+                return { pass: false, message: `Expected to check text '${expected}' on element, but element was falsy` };
+            }
+            if (!(el instanceof TestElement)) {
+                return { pass: false, message: `Expected to check text '${expected}' on element, but element was not a TestElement` };
+            }
+            const actual = el.textContent;
+            if (!actual) {
+                return {
+                    pass: isNegative,
+                    message: `Expected element to ${isNegative ? 'not ' : ''}contain text '${expected}', but had no text`
+                };
+            }
+            const pass = actual.indexOf(expected) !== -1;
+            const message = `Expected element to ${isNegative ? 'not ' : ''}contain text '${expected}', but had text '${actual}'`;
+            return { pass: isNegative ? !pass : pass, message };
+        };
+        return {
+            compare: (el, expected) => {
+                return assert(false, el, expected);
+            },
+            negativeCompare: (el, expected) => {
+                return assert(true, el, expected);
+            }
+        };
+    },
+    /**
+     * Checks that the receiver is a TestElement wrapping a DOM element and contains the given textContent
+     */
+    toBeChecked: () => {
+        const assert = (isNegative, el) => {
+            if (!el) {
+                return { pass: false, message: `Expected to check if element was checked, but element was falsy` };
+            }
+            if (!(el instanceof TestInput)) {
+                return { pass: false, message: `Expected to check if element was checked, but element was not a TestInput` };
+            }
+            const pass = el.checked;
+            const message = `Expected element to be ${isNegative ? 'not ' : ''}checked, but was${!isNegative ? ' not' : ''}`;
+            return { pass: isNegative ? !pass : pass, message };
+        };
+        return {
+            compare: (el) => {
+                return assert(false, el);
+            },
+            negativeCompare: (el) => {
+                return assert(true, el);
+            }
+        };
+    },
+    /**
+     * Checks that the receiver is a TestSelect wrapping a DOM element and has the given selected index
+     */
+    toHaveSelectedIndex: () => {
+        const assert = (isNegative, el, expected) => {
+            if (!el) {
+                return { pass: false, message: `Expected to check selected index ${expected} on element, but element was falsy` };
+            }
+            if (!(el instanceof TestSelect)) {
+                return { pass: false, message: `Expected to check selected index ${expected} on element, but element was not a TestSelect` };
+            }
+            const actual = el.selectedIndex;
+            const pass = actual === expected;
+            const message = `Expected element to ${isNegative ? 'not ' : ''}have selected index ${expected}, but had ${actual}`;
+            return { pass: isNegative ? !pass : pass, message };
+        };
+        return {
+            compare: (el, expected) => {
+                return assert(false, el, expected);
+            },
+            negativeCompare: (el, expected) => {
+                return assert(true, el, expected);
+            }
+        };
+    },
+    /**
+     * Checks that the receiver is a TestSelect wrapping a DOM element with the selected option's value equal to the given value
+     */
+    toHaveSelectedValue: () => {
+        const assert = (isNegative, el, expected) => {
+            if (!el) {
+                return { pass: false, message: `Expected to check selected value '${expected}' on element, but element was falsy` };
+            }
+            if (!(el instanceof TestSelect)) {
+                return { pass: false, message: `Expected to check selected value '${expected}' on element, but element was not a TestSelect` };
+            }
+            const actual = el.selectedValue;
+            const pass = actual === expected;
+            const message = `Expected element to ${isNegative ? 'not ' : ''}have selected value '${expected}', but had '${actual}'`;
+            return { pass: isNegative ? !pass : pass, message };
+        };
+        return {
+            compare: (el, expected) => {
+                return assert(false, el, expected);
+            },
+            negativeCompare: (el, expected) => {
+                return assert(true, el, expected);
+            }
+        };
+    },
+    /**
+     * Checks that the receiver is a TestSelect wrapping a DOM element with the selected option's label equal to the given label
+     */
+    toHaveSelectedLabel: () => {
+        const assert = (isNegative, el, expected) => {
+            if (!el) {
+                return { pass: false, message: `Expected to check selected label '${expected}' on element, but element was falsy` };
+            }
+            if (!(el instanceof TestSelect)) {
+                return { pass: false, message: `Expected to check selected label '${expected}' on element, but element was not a TestSelect` };
+            }
+            const actual = el.selectedLabel;
+            const pass = actual === expected;
+            const message = `Expected element to ${isNegative ? 'not ' : ''}have selected label '${expected}', but had '${actual}'`;
+            return { pass: isNegative ? !pass : pass, message };
+        };
+        return {
+            compare: (el, expected) => {
+                return assert(false, el, expected);
+            },
+            negativeCompare: (el, expected) => {
+                return assert(true, el, expected);
+            }
+        };
+    },
+    /**
+     * Checks that the receiver is a TestHtmlElement which is visible
+     */
+    toBeVisible: () => {
+        const assert = (isNegative, el) => {
+            const expectedState = `${isNegative ? 'in' : ''}visible`;
+            const inverseState = `${isNegative ? '' : 'in'}visible`;
+            if (!el) {
+                return { pass: false, message: `Expected to check if element was ${expectedState}, but element was falsy` };
+            }
+            if (!(el instanceof TestHtmlElement)) {
+                return { pass: false, message: `Expected to check if element was ${expectedState}, but element was not a TestHtmlElement` };
+            }
+            const pass = el.visible;
+            const message = `Expected element to be ${expectedState}, but was ${inverseState}`;
+            return { pass: isNegative ? !pass : pass, message };
+        };
+        return {
+            compare: (el) => {
+                return assert(false, el);
+            },
+            negativeCompare: (el) => {
+                return assert(true, el);
+            }
+        };
+    }
+};
+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"]}

package/esm2020/lib/mock.mjs

@@ -0,0 +1,25 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function collectMethodNames(proto) {
+    if (!proto || proto === Object.prototype) {
+        return [];
+    }
+    const methodNames = [];
+    for (const key of Object.getOwnPropertyNames(proto)) {
+        const descriptor = Object.getOwnPropertyDescriptor(proto, key);
+        if (descriptor && typeof descriptor.value === 'function' && key !== 'constructor') {
+            methodNames.push(key);
+        }
+    }
+    return [...methodNames, ...collectMethodNames(Object.getPrototypeOf(proto))];
+}
+/**
+ * Creates a spy object for a class where all the methods of the class (and of its superclasses) are spies.
+ * I.e., for a class `UserService` with methods `get()`, `create()`, `update()` and `delete()`, calling
+ * `createMock(UserService)` is equivalent to calling
+ * `jasmine.createSpyObj<UserService>('UserService', ['get', 'create', 'update', 'delete']).
+ * @param type the type to mock (usually a service class)
+ */
+export function createMock(type) {
+    return jasmine.createSpyObj(type.name, collectMethodNames(type.prototype));
+}
+//# sourceMappingURL=data:application/json;base64,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