ngx-speculoos 6.0.0 → 7.2.0

package/fesm2015/ngx-speculoos.mjs

@@ -0,0 +1,1257 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { convertToParamMap, ActivatedRouteSnapshot, ActivatedRoute } from '@angular/router';
+import { map, BehaviorSubject } from 'rxjs';
+
+/**
+ * A wrapped DOM element, providing additional methods and attributes helping with writing tests
+ */
+class TestElement {
+    constructor(tester, 
+    /**
+     * the wrapped debug element
+     */
+    debugElement) {
+        this.tester = tester;
+        this.debugElement = debugElement;
+        this.querier = new TestElementQuerier(tester, debugElement);
+    }
+    get nativeElement() {
+        return this.debugElement.nativeElement;
+    }
+    /**
+     * the text content of this element
+     */
+    get textContent() {
+        return this.nativeElement.textContent;
+    }
+    /**
+     * dispatches an event of the given type from the wrapped element, then triggers a change detection
+     */
+    dispatchEventOfType(type) {
+        this.nativeElement.dispatchEvent(new Event(type));
+        this.tester.detectChanges();
+    }
+    /**
+     * dispatches the given event from the wrapped element, then triggers a change detection
+     */
+    dispatchEvent(event) {
+        this.nativeElement.dispatchEvent(event);
+        this.tester.detectChanges();
+    }
+    /**
+     * Gets the CSS classes of the wrapped element, as an array
+     */
+    get classes() {
+        return Array.prototype.slice.call(this.nativeElement.classList);
+    }
+    /**
+     * Gets the attribute of the wrapped element with the given name
+     * @param name the name of the attribute to get
+     */
+    attr(name) {
+        return this.nativeElement.getAttribute(name);
+    }
+    element(selector) {
+        return this.querier.element(selector);
+    }
+    elements(selector) {
+        return this.querier.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.querier.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.querier.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.querier.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.querier.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) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.querier.element(selector)) === null || _a === void 0 ? void 0 : _a.debugElement) === null || _b === void 0 ? void 0 : _b.componentInstance) !== null && _c !== void 0 ? _c : null;
+    }
+    /**
+     * 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.querier.elements(selector).map(e => e.debugElement.componentInstance);
+    }
+    /**
+     * 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) {
+        var _a, _b, _c, _d;
+        return (_d = (_c = (_b = (_a = this.querier.element(selector)) === null || _a === void 0 ? void 0 : _a.debugElement) === null || _b === void 0 ? void 0 : _b.injector) === null || _c === void 0 ? void 0 : _c.get(token, null)) !== null && _d !== void 0 ? _d : null;
+    }
+    /**
+     * 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.querier.elements(selector).map(e => { var _a; return (_a = e.debugElement.injector.get(token, null)) !== null && _a !== void 0 ? _a : null; });
+    }
+    /**
+     * 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) {
+        const element = this.querier.element(selector);
+        return element && new customTestElementType(this.tester, element.debugElement);
+    }
+    /**
+     * 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.querier.elements(selector).map(element => new customTestElementType(this.tester, element.debugElement));
+    }
+}
+
+/**
+ * A wrapped DOM HTML element, providing additional methods and attributes helping with writing tests
+ */
+class TestHtmlElement extends TestElement {
+    constructor(tester, debugElement) {
+        super(tester, debugElement);
+    }
+    /**
+     * Clicks on the wrapped element, then triggers a change detection
+     */
+    click() {
+        this.nativeElement.click();
+        this.tester.detectChanges();
+    }
+    /**
+     * Tests if the element is visible, in the same meaning (and implementation) as in jQuery, i.e.
+     * present anywhere in the DOM, and visible.
+     * An element is not visible typically, if its display style or any of its ancestors display style is none.
+     */
+    get visible() {
+        return !!(this.nativeElement.offsetWidth || this.nativeElement.offsetHeight || this.nativeElement.getClientRects().length);
+    }
+}
+
+/**
+ * A wrapped button element, providing additional methods and attributes helping with writing tests
+ */
+class TestButton extends TestHtmlElement {
+    constructor(tester, debugElement) {
+        super(tester, debugElement);
+    }
+    /**
+     * the disabled flag of the button
+     */
+    get disabled() {
+        return this.nativeElement.disabled;
+    }
+}
+
+/**
+ * A wrapped DOM HTML select element, providing additional methods and attributes helping with writing tests
+ */
+class TestSelect extends TestHtmlElement {
+    constructor(tester, debugElement) {
+        super(tester, debugElement);
+    }
+    /**
+     * Selects the option at the given index, then dispatches an event of type change and triggers a change detection
+     */
+    selectIndex(index) {
+        this.nativeElement.selectedIndex = index;
+        this.dispatchEventOfType('change');
+    }
+    /**
+     * Selects the first option with the given value, then dispatches an event of type change and triggers a change detection.
+     * If there is no option with the given value, then does nothing
+     * TODO should it throw instead?
+     */
+    selectValue(value) {
+        const index = this.optionValues.indexOf(value);
+        if (index >= 0) {
+            this.selectIndex(index);
+        }
+    }
+    /**
+     * Selects the first option with the given label (or text), then dispatches an event of type change and triggers a change detection.
+     * If there is no option with the given label, then does nothing
+     * TODO should it throw instead?
+     */
+    selectLabel(label) {
+        const index = this.optionLabels.indexOf(label);
+        if (index >= 0) {
+            this.selectIndex(index);
+        }
+    }
+    /**
+     * the selected index of the wrapped select
+     */
+    get selectedIndex() {
+        return this.nativeElement.selectedIndex;
+    }
+    /**
+     * the value of the selected option of the wrapped select, or null if there is no selected option
+     */
+    get selectedValue() {
+        if (this.selectedIndex < 0) {
+            return null;
+        }
+        return this.nativeElement.options[this.selectedIndex].value;
+    }
+    /**
+     * the label (or text if no label) of the selected option of the wrapped select, or null if there is no selected option
+     */
+    get selectedLabel() {
+        if (this.selectedIndex < 0) {
+            return null;
+        }
+        return this.nativeElement.options[this.selectedIndex].label;
+    }
+    /**
+     * the values of the options, as an array
+     */
+    get optionValues() {
+        return Array.prototype.slice.call(this.nativeElement.options).map(option => option.value);
+    }
+    /**
+     * the labels (or texts if no label) of the options, as an array
+     */
+    get optionLabels() {
+        return Array.prototype.slice.call(this.nativeElement.options).map(option => option.label);
+    }
+    /**
+     * the number of options in the select
+     */
+    get size() {
+        return this.nativeElement.options.length;
+    }
+    /**
+     * the disabled property of the wrapped select
+     */
+    get disabled() {
+        return this.nativeElement.disabled;
+    }
+}
+
+/**
+ * A wrapped DOM HTML textarea element, providing additional methods and attributes helping with writing tests
+ */
+class TestTextArea extends TestHtmlElement {
+    constructor(tester, debugElement) {
+        super(tester, debugElement);
+    }
+    /**
+     * Sets the value of the wrapped textarea, then dispatches an event of type input and triggers a change detection
+     * @param value the new value of the textarea
+     */
+    fillWith(value) {
+        this.nativeElement.value = value;
+        this.dispatchEventOfType('input');
+    }
+    /**
+     * the value of the wrapped textarea
+     */
+    get value() {
+        return this.nativeElement.value;
+    }
+    /**
+     * the disabled property of the wrapped textarea
+     */
+    get disabled() {
+        return this.nativeElement.disabled;
+    }
+}
+
+/**
+ * A wrapped DOM HTML input element, providing additional methods and attributes helping with writing tests
+ */
+class TestInput extends TestHtmlElement {
+    constructor(tester, debugElement) {
+        super(tester, debugElement);
+    }
+    /**
+     * Sets the value of the wrapped input, then dispatches an event of type input and triggers a change detection
+     * @param value the new value of the input
+     */
+    fillWith(value) {
+        this.nativeElement.value = value;
+        this.dispatchEventOfType('input');
+    }
+    /**
+     * the value of the wrapped input
+     */
+    get value() {
+        return this.nativeElement.value;
+    }
+    /**
+     * the checked property of the wrapped input
+     */
+    get checked() {
+        return this.nativeElement.checked;
+    }
+    /**
+     * the disabled property of the wrapped input
+     */
+    get disabled() {
+        return this.nativeElement.disabled;
+    }
+    /**
+     * Checks the wrapped input, then dispatches an event of type change and triggers a change detection
+     */
+    check() {
+        this.nativeElement.checked = true;
+        this.dispatchEventOfType('change');
+    }
+    /**
+     * Unchecks the wrapped input, then dispatches an event of type change and triggers a change detection
+     */
+    uncheck() {
+        this.nativeElement.checked = false;
+        this.dispatchEventOfType('change');
+    }
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * @internal
+ */
+class TestElementQuerier {
+    constructor(tester, root) {
+        this.tester = tester;
+        this.root = root;
+    }
+    static wrap(childDebugElement, tester) {
+        const childElement = childDebugElement.nativeElement;
+        if (childElement instanceof HTMLButtonElement) {
+            return new TestButton(tester, childDebugElement);
+        }
+        else if (childElement instanceof HTMLInputElement) {
+            return new TestInput(tester, childDebugElement);
+        }
+        else if (childElement instanceof HTMLSelectElement) {
+            return new TestSelect(tester, childDebugElement);
+        }
+        else if (childElement instanceof HTMLTextAreaElement) {
+            return new TestTextArea(tester, childDebugElement);
+        }
+        else if (childElement instanceof HTMLElement) {
+            return new TestHtmlElement(tester, childDebugElement);
+        }
+        else {
+            return new TestElement(tester, childDebugElement);
+        }
+    }
+    /**
+     * Gets the first element matching the given selector and wraps it into a TestElement. The actual type
+     * of the returned value is the TestElement subclass matching the type of the found element. So, if the
+     * matched element is an input for example, the method will return a TestInput. You can thus use
+     * `tester.element('#some-input') as TestInput`.
+     * @param selector a CSS or directive selector
+     * @returns the wrapped element, or null if no element matches the selector.
+     */
+    element(selector) {
+        const childElement = this.query(selector);
+        return childElement && TestElementQuerier.wrap(childElement, this.tester);
+    }
+    /**
+     * Gets all the elements matching the given selector and wraps them into a TestElement. The actual type
+     * of the returned elements is the TestElement subclass matching the type of the found element. So, if the
+     * matched elements are inputs for example, the method will return an array of TestInput. You can thus use
+     * `tester.elements('input') as Array<TestInput>`.
+     * @param selector a CSS or directive selector
+     * @returns the array of matched elements, empty if no element was matched
+     */
+    elements(selector) {
+        const childElements = this.queryAll(selector);
+        return childElements.map(debugElement => TestElementQuerier.wrap(debugElement, this.tester));
+    }
+    /**
+     * 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) {
+        const childElement = this.query(selector);
+        if (!childElement) {
+            return null;
+        }
+        else if (!(childElement.nativeElement instanceof HTMLInputElement)) {
+            throw new Error(`Element with selector ${selector} is not an HTMLInputElement`);
+        }
+        return new TestInput(this.tester, childElement);
+    }
+    /**
+     * 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) {
+        const childElement = this.query(selector);
+        if (!childElement) {
+            return null;
+        }
+        else if (!(childElement.nativeElement instanceof HTMLSelectElement)) {
+            throw new Error(`Element with selector ${selector} is not an HTMLSelectElement`);
+        }
+        return new TestSelect(this.tester, childElement);
+    }
+    /**
+     * 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) {
+        const childElement = this.query(selector);
+        if (!childElement) {
+            return null;
+        }
+        else if (!(childElement.nativeElement instanceof HTMLTextAreaElement)) {
+            throw new Error(`Element with selector ${selector} is not an HTMLTextAreaElement`);
+        }
+        return new TestTextArea(this.tester, childElement);
+    }
+    /**
+     * 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) {
+        const childElement = this.query(selector);
+        if (!childElement) {
+            return null;
+        }
+        else if (!(childElement.nativeElement instanceof HTMLButtonElement)) {
+            throw new Error(`Element with selector ${selector} is not an HTMLButtonElement`);
+        }
+        return new TestButton(this.tester, childElement);
+    }
+    query(selector) {
+        if (typeof selector === 'string') {
+            return this.root.query(By.css(selector));
+        }
+        else {
+            return this.root.query(By.directive(selector));
+        }
+    }
+    queryAll(selector) {
+        if (typeof selector === 'string') {
+            return this.root.queryAll(By.css(selector));
+        }
+        else {
+            return this.root.queryAll(By.directive(selector));
+        }
+    }
+}
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * 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
+ */
+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);
+    }
+}
+
+/**
+ * Creates a fake partial ActivatedRoute for tests.
+ *
+ * If you pass params, then the created route's paramMap will contain the same values.
+ * The same goes for queryParams and queryParamMap.
+ *
+ * If you pass a parent route and a snapshot, and the passed snapshot doesn't have a parent, then the snapshot's
+ * parent will be set to the parent route snapshot. This allows the code under test to use
+ * `route.parent.snapshot` or `route.snapshot.parent`.
+ *
+ * If you pass a snapshot with a parent, but don't pass a parent or pass a parent without snapshot, then the route's
+ * parent snapshot will be set to the given snapshot's parent. This allows the code under test to use
+ * `route.parent.snapshot` or `route.snapshot.parent`.
+ *
+ * @returns a partially populated, fake ActivatedRoute, depending on what you passed in
+ * @deprecated favor stubRoute, which creates an easier to use and more logical stub
+ */
+function fakeRoute(options) {
+    const result = {
+        url: options.url,
+        params: options.params,
+        paramMap: options.params && options.params.pipe(map(params => convertToParamMap(params))),
+        queryParams: options.queryParams,
+        queryParamMap: options.queryParams && options.queryParams.pipe(map(params => convertToParamMap(params))),
+        fragment: options.fragment,
+        data: options.data,
+        outlet: options.outlet,
+        component: options.component,
+        snapshot: options.snapshot,
+        routeConfig: options.routeConfig,
+        root: options.root,
+        parent: options.parent,
+        firstChild: options.firstChild,
+        children: options.children,
+        pathFromRoot: options.pathFromRoot
+    };
+    for (let route = result; route; route = route.parent) {
+        if (route.parent && route.parent.snapshot && !route.snapshot) {
+            // eslint-disable-next-line deprecation/deprecation
+            route.snapshot = fakeSnapshot({});
+        }
+        if (route.parent && route.parent.snapshot && !route.snapshot.parent) {
+            route.snapshot.parent = route.parent.snapshot;
+        }
+        if (route.snapshot && route.snapshot.parent && !route.parent) {
+            // eslint-disable-next-line deprecation/deprecation
+            route.parent = fakeRoute({});
+        }
+        if (route.snapshot && route.snapshot.parent && route.parent && !route.parent.snapshot) {
+            route.parent.snapshot = route.snapshot.parent;
+        }
+    }
+    return result;
+}
+/**
+ * Creates a fake partial ActivatedRouteSnapshot for tests.
+ *
+ * If you pass params, then the created snapshot's paramMap will contain the same values.
+ * The same goes for queryParams and queryParamMap.
+ *
+ * @returns a partially populated, fake ActivatedRoute, depending on what you passed in
+ * @deprecated favor stubRoute, which creates an easier to use and more logical stub for both the route and its snapshot
+ */
+function fakeSnapshot(options) {
+    return {
+        url: options.url,
+        params: options.params,
+        paramMap: options.params && convertToParamMap(options.params),
+        queryParams: options.queryParams,
+        queryParamMap: options.queryParams && convertToParamMap(options.queryParams),
+        fragment: options.fragment,
+        data: options.data,
+        outlet: options.outlet,
+        component: options.component,
+        routeConfig: options.routeConfig,
+        root: options.root,
+        parent: options.parent,
+        firstChild: options.firstChild,
+        children: options.children,
+        pathFromRoot: options.pathFromRoot
+    };
+}
+class ActivatedRouteSnapshotStub extends ActivatedRouteSnapshot {
+    constructor() {
+        super();
+        this._parent = null;
+        this._firstChild = null;
+        this._children = [];
+        this._pathFromRoot = [];
+        this._routeConfig = null;
+        this._root = this;
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    get root() {
+        return this._root;
+    }
+    set root(value) {
+        this._root = value;
+    }
+    get firstChild() {
+        return this._firstChild;
+    }
+    set firstChild(value) {
+        this._firstChild = value;
+    }
+    get children() {
+        return this._children;
+    }
+    set children(value) {
+        this._children = value;
+    }
+    get pathFromRoot() {
+        return this._pathFromRoot;
+    }
+    set pathFromRoot(value) {
+        this._pathFromRoot = value;
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    get routeConfig() {
+        return this._routeConfig;
+    }
+    set routeConfig(route) {
+        this._routeConfig = route;
+    }
+}
+/**
+ * A stub for ActivatedRoute. It behaves almost the same way as the actual ActivatedRoute, exposing a snapshot
+ * and observables for the params, query params etc., which are kept in sync.
+ *
+ * In addition, this stub allows simulating a navigation by changing the params, the query params, the fragment, etc.
+ * When that happens, the snapshot is modified, then the relevant observables emit the new values.
+ *
+ * There are some things that don't really work the same way as the real ActivatedRoute though:
+ * - the handling of the firstChild and of the children is entirely under the tester's responsibility. Setting the parent
+ *   of a route stub does not add this route to the children of its parent, for example.
+ * - when changing the params, query params, fragment, etc., their associated observable emits unconditionally, instead of
+ *   first checking if the value is actually different from before. It's thus the responsibility of the tester to not
+ *   change the values if they're the same as before.
+ */
+class ActivatedRouteStub extends ActivatedRoute {
+    /**
+     * Constructs a new instance, based on the given options.
+     * If an option is not provided (or if no option is provided at all), then the route has a default value for this option
+     * (empty parameters for example, null fragment, etc.)
+     * If no parent is passed, then this route has no parent and is thus set as the root. Otherwise, the root and the path
+     * from root are created based on the root and path from root of the given parent route.
+     */
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        super();
+        const snapshot = new ActivatedRouteSnapshotStub();
+        this.snapshot = snapshot;
+        this._firstChild = (_a = options === null || options === void 0 ? void 0 : options.firstChild) !== null && _a !== void 0 ? _a : null;
+        this._children = (_b = options === null || options === void 0 ? void 0 : options.children) !== null && _b !== void 0 ? _b : [];
+        this._parent = (_c = options === null || options === void 0 ? void 0 : options.parent) !== null && _c !== void 0 ? _c : null;
+        this._root = (_e = (_d = this.parent) === null || _d === void 0 ? void 0 : _d.root) !== null && _e !== void 0 ? _e : this;
+        this._pathFromRoot = this.parent ? [...this.parent.pathFromRoot, this] : [this];
+        snapshot.params = (_f = options === null || options === void 0 ? void 0 : options.params) !== null && _f !== void 0 ? _f : {};
+        snapshot.queryParams = (_g = options === null || options === void 0 ? void 0 : options.queryParams) !== null && _g !== void 0 ? _g : {};
+        snapshot.data = (_h = options === null || options === void 0 ? void 0 : options.data) !== null && _h !== void 0 ? _h : {};
+        snapshot.fragment = (_j = options === null || options === void 0 ? void 0 : options.fragment) !== null && _j !== void 0 ? _j : null;
+        snapshot.url = (_k = options === null || options === void 0 ? void 0 : options.url) !== null && _k !== void 0 ? _k : [];
+        snapshot.routeConfig = (_l = options === null || options === void 0 ? void 0 : options.routeConfig) !== null && _l !== void 0 ? _l : null;
+        snapshot.firstChild = (_o = (_m = this.firstChild) === null || _m === void 0 ? void 0 : _m.snapshot) !== null && _o !== void 0 ? _o : null;
+        snapshot.children = (_q = (_p = this.children) === null || _p === void 0 ? void 0 : _p.map(route => route.snapshot)) !== null && _q !== void 0 ? _q : [];
+        snapshot.parent = (_s = (_r = this.parent) === null || _r === void 0 ? void 0 : _r.snapshot) !== null && _s !== void 0 ? _s : null;
+        snapshot.root = this.root.snapshot;
+        snapshot.pathFromRoot = this.pathFromRoot.map(route => route.snapshot);
+        this.paramsSubject = new BehaviorSubject(this.snapshot.params);
+        this.queryParamsSubject = new BehaviorSubject(this.snapshot.queryParams);
+        this.dataSubject = new BehaviorSubject(this.snapshot.data);
+        this.fragmentSubject = new BehaviorSubject(this.snapshot.fragment);
+        this.urlSubject = new BehaviorSubject(this.snapshot.url);
+        this.params = this.paramsSubject.asObservable();
+        this.queryParams = this.queryParamsSubject.asObservable();
+        this.data = this.dataSubject.asObservable();
+        this.fragment = this.fragmentSubject.asObservable();
+        this.url = this.urlSubject.asObservable();
+    }
+    get root() {
+        return this._root;
+    }
+    get parent() {
+        return this._parent;
+    }
+    get pathFromRoot() {
+        return this._pathFromRoot;
+    }
+    get firstChild() {
+        return this._firstChild;
+    }
+    get children() {
+        return this._children;
+    }
+    get routeConfig() {
+        return this.snapshot.routeConfig;
+    }
+    /**
+     * Triggers a navigation with the given new parameters. All the other parts (query params etc.) stay as the are.
+     * This is a shortcut to `triggerNavigation` that can be used to only change the parameters.
+     */
+    setParams(params) {
+        this.triggerNavigation({ params });
+    }
+    /**
+     * Triggers a navigation with the given new parameter. The other parameters, as well as all the other parts (query params etc.)
+     * stay as the are.
+     * This is a shortcut to `triggerNavigation` that can be used to only change one parameter.
+     */
+    setParam(name, value) {
+        this.setParams(Object.assign(Object.assign({}, this.snapshot.params), { [name]: value }));
+    }
+    /**
+     * Triggers a navigation with the given new query parameters. All the other parts (params etc.) stay as the are.
+     * This is a shortcut to `triggerNavigation` that can be used to only change the query parameters.
+     */
+    setQueryParams(queryParams) {
+        this.triggerNavigation({ queryParams });
+    }
+    /**
+     * Triggers a navigation with the given new parameter. The other query parameters, as well as all the other parts (params etc.)
+     * stay as the are.
+     * This is a shortcut to `triggerNavigation` that can be used to only change one query parameter.
+     */
+    setQueryParam(name, value) {
+        this.setQueryParams(Object.assign(Object.assign({}, this.snapshot.queryParams), { [name]: value }));
+    }
+    /**
+     * Triggers a navigation with the given new data. The other parameters, as well as all the other parts (params etc.)
+     * stay as the are.
+     * This is a shortcut to `triggerNavigation` that can be used to only change the data.
+     */
+    setData(data) {
+        this.triggerNavigation({ data });
+    }
+    /**
+     * Triggers a navigation with the given new data item. The other data, as well as all the other parts (params etc.)
+     * stay as the are.
+     * This is a shortcut to `triggerNavigation` that can be used to only change one data item.
+     */
+    setDataItem(name, value) {
+        this.setData(Object.assign(Object.assign({}, this.snapshot.data), { [name]: value }));
+    }
+    /**
+     * Triggers a navigation with the given new fragment. The other parts (params etc.)  stay as the are.
+     * This is a shortcut to `triggerNavigation` that can be used to only change the fragment.
+     */
+    setFragment(fragment) {
+        this.triggerNavigation({ fragment });
+    }
+    /**
+     * Triggers a navigation with the given new url. The other parts (params etc.)  stay as the are.
+     * This is a shortcut to `triggerNavigation` that can be used to only change the url.
+     */
+    setUrl(url) {
+        this.triggerNavigation({ url });
+    }
+    /**
+     * Triggers a navigation based on the given options. If an option is undefined or null, it's ignored. Except for fragment, which is only
+     * ignored if it's undefined, because null is a valid value for a fragment.
+     *
+     * The non-ignored values are used to change the snapshot of the route. Once the snapshot has been modified,
+     * the observables corresponding to the updated parts emit the new value.
+     *
+     * So, setting params and query params will make the params and queryParams observables emit, but not the fragment, data and
+     * url observables for example. This is consistent to how the router behaves.
+     */
+    triggerNavigation(options) {
+        // set the snapshot first
+        if (options.params) {
+            this.snapshot.params = options.params;
+        }
+        if (options.queryParams) {
+            this.snapshot.queryParams = options.queryParams;
+        }
+        if (options.fragment !== undefined) {
+            this.snapshot.fragment = options.fragment;
+        }
+        if (options.data) {
+            this.snapshot.data = options.data;
+        }
+        if (options.url) {
+            this.snapshot.url = options.url;
+        }
+        // then emit everything that has changed
+        if (options.params) {
+            this.paramsSubject.next(this.snapshot.params);
+        }
+        if (options.queryParams) {
+            this.queryParamsSubject.next(this.snapshot.queryParams);
+        }
+        if (options.fragment !== undefined) {
+            this.fragmentSubject.next(this.snapshot.fragment);
+        }
+        if (options.data) {
+            this.dataSubject.next(this.snapshot.data);
+        }
+        if (options.url) {
+            this.urlSubject.next(this.snapshot.url);
+        }
+    }
+    toString() {
+        return 'ActivatedRouteStub';
+    }
+}
+/**
+ * Creates a new ActivatedRouteStub, by calling its constructor.
+ */
+function stubRoute(options) {
+    return new ActivatedRouteStub(options);
+}
+
+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) => {
+            var _a;
+            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 = (_a = el.textContent) === null || _a === void 0 ? void 0 : _a.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);
+            }
+        };
+    }
+};
+
+// 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)
+ */
+function createMock(type) {
+    return jasmine.createSpyObj(type.name, collectMethodNames(type.prototype));
+}
+
+/* eslint-disable */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ActivatedRouteStub, ComponentTester, TestButton, TestElement, TestHtmlElement, TestInput, TestSelect, TestTextArea, createMock, fakeRoute, fakeSnapshot, speculoosMatchers, stubRoute };
+//# sourceMappingURL=ngx-speculoos.mjs.map