ngx-speculoos 6.0.0 → 7.2.0

package/lib/route.d.ts

@@ -16,6 +16,7 @@ import { Type } from '@angular/core';
  * `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
  */
 export declare function fakeRoute(options: {
     url?: Observable<UrlSegment[]>;
@@ -53,6 +54,7 @@ export declare function fakeRoute(options: {
  * 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
  */
 export declare function fakeSnapshot(options: {
     url?: UrlSegment[];
@@ -81,3 +83,150 @@ export declare function fakeSnapshot(options: {
     /** The path from the root of the router state tree to this route */
     pathFromRoot?: ActivatedRouteSnapshot[];
 }): ActivatedRouteSnapshot;
+/**
+ * The options that are passed when creating an ActivatedRouteStub.
+ */
+export interface ActivatedRouteStubOptions {
+    /**
+     * The initial values of the parameters of the route
+     */
+    params?: Params;
+    /**
+     * The initial values of the query parameters of the route
+     */
+    queryParams?: Params;
+    /**
+     * The initial values of the data of the route
+     */
+    data?: Data;
+    /**
+     * The initial fragment of the route
+     */
+    fragment?: string | null;
+    /**
+     * The initial url of the route
+     */
+    url?: UrlSegment[];
+    /**
+     * The parent of the route
+     */
+    parent?: ActivatedRouteStub | null;
+    /**
+     * The first child of the route
+     */
+    firstChild?: ActivatedRouteStub | null;
+    /**
+     * The children of the route
+     */
+    children?: ActivatedRouteStub[] | null;
+    /**
+     * The configuration of the route
+     */
+    routeConfig?: Route | null;
+}
+/**
+ * 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.
+ */
+export declare class ActivatedRouteStub extends ActivatedRoute {
+    private _firstChild;
+    private _children;
+    private readonly paramsSubject;
+    private readonly queryParamsSubject;
+    private readonly dataSubject;
+    private readonly fragmentSubject;
+    private readonly urlSubject;
+    private _parent;
+    private _root;
+    private _pathFromRoot;
+    /**
+     * 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?: ActivatedRouteStubOptions);
+    get root(): ActivatedRouteStub;
+    get parent(): ActivatedRouteStub | null;
+    get pathFromRoot(): Array<ActivatedRouteStub>;
+    get firstChild(): ActivatedRouteStub | null;
+    get children(): Array<ActivatedRouteStub>;
+    get routeConfig(): Route | null;
+    /**
+     * 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: Params): void;
+    /**
+     * 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: string, value: string): void;
+    /**
+     * 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: Params): void;
+    /**
+     * 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: string, value: string): void;
+    /**
+     * 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: Data): void;
+    /**
+     * 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: string, value: unknown): void;
+    /**
+     * 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: string | null): void;
+    /**
+     * 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: Array<UrlSegment>): void;
+    /**
+     * 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: {
+        params?: Params;
+        queryParams?: Params;
+        fragment?: string | null;
+        data?: Data | null;
+        url?: Array<UrlSegment> | null;
+    }): void;
+    toString(): string;
+}
+/**
+ * Creates a new ActivatedRouteStub, by calling its constructor.
+ */
+export declare function stubRoute(options?: ActivatedRouteStubOptions): ActivatedRouteStub;

package/lib/test-element-querier.d.ts

@@ -4,7 +4,7 @@ import { TestElement } from './test-element';
 import { TestTextArea } from './test-textarea';
 import { TestInput } from './test-input';
 import { ComponentTester } from './component-tester';
-import { DebugElement } from '@angular/core';
+import { DebugElement, Type } from '@angular/core';
 /**
  * @internal
  */
@@ -14,48 +14,48 @@ export declare class TestElementQuerier {
     constructor(tester: ComponentTester<unknown>, root: DebugElement);
     static wrap(childDebugElement: DebugElement, tester: ComponentTester<unknown>): TestElement;
     /**
-     * Gets the first element matching the given CSS selector and wraps it into a TestElement. The actual type
+     * 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 selector
+     * @param selector a CSS or directive selector
      * @returns the wrapped element, or null if no element matches the selector.
      */
-    element(selector: string): TestElement | null;
+    element(selector: string | Type<any>): TestElement | null;
     /**
-     * Gets all the elements matching the given CSS selector and wraps them into a TestElement. The actual type
+     * 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 selector
+     * @param selector a CSS or directive selector
      * @returns the array of matched elements, empty if no element was matched
      */
-    elements(selector: string): Array<TestElement>;
+    elements(selector: string | Type<any>): Array<TestElement>;
     /**
      * 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 selector
+     * @param selector a CSS or directive selector
      * @returns the wrapped input, or null if no element was matched
      */
-    input(selector: string): TestInput | null;
+    input(selector: string | Type<any>): TestInput | null;
     /**
      * 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 selector
+     * @param selector a CSS or directive selector
      * @returns the wrapped select, or null if no element was matched
      */
-    select(selector: string): TestSelect | null;
+    select(selector: string | Type<any>): TestSelect | null;
     /**
      * Gets the first textarea matched by the given selector
-     * @param selector a CSS 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: string): TestTextArea | null;
+    textarea(selector: string | Type<any>): TestTextArea | null;
     /**
      * 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 selector
+     * @param selector a CSS or directive selector
      * @returns the wrapped button, or null if no element was matched
      */
-    button(selector: string): TestButton | null;
+    button(selector: string | Type<any>): TestButton | null;
     private query;
     private queryAll;
 }

package/lib/test-element.d.ts

@@ -3,7 +3,7 @@ import { TestButton } from './test-button';
 import { TestSelect } from './test-select';
 import { TestTextArea } from './test-textarea';
 import { TestInput } from './test-input';
-import { DebugElement } from '@angular/core';
+import { DebugElement, ProviderToken, Type } from '@angular/core';
 import { TestHtmlElement } from './test-html-element';
 /**
  * A wrapped DOM element, providing additional methods and attributes helping with writing tests
@@ -74,82 +74,82 @@ export declare class TestElement<E extends Element = Element> {
      * <code>
      * const testElement: TestElement | null = tester.element('.selector');
      * </code>
-     * @param selector a CSS selector
+     * @param selector a CSS or directive selector
      * @returns the wrapped element, or null if no element matches the selector.
      */
-    element(selector: string): TestElement | null;
+    element(selector: string | Type<any>): TestElement | null;
     /**
-     * Gets the first element matching the given CSS selector and wraps it into a TestElement. The actual type
+     * 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.
      * <p>Usage:</p>
      * <code>
      * const testElement: TestInput | null = tester.element&lt;HTMLInputElement>('.selector');
      * </code>
-     * @param selector a CSS selector
+     * @param selector a CSS or directive selector
      * @returns the wrapped element, or null if no element matches the selector.
      */
-    element<T extends HTMLInputElement>(selector: string): TestInput | null;
+    element<T extends HTMLInputElement>(selector: string | Type<any>): TestInput | null;
     /**
-     * Gets the first element matching the given CSS selector and wraps it into a TestElement. The actual type
+     * 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.
      * <p>Usage:</p>
      * <code>
      * const testElement: TestTextArea | null = tester.element&lt;HTMLTextAreaElement>('.selector');
      * </code>
-     * @param selector a CSS selector
+     * @param selector a CSS or directive selector
      * @returns the wrapped element, or null if no element matches the selector.
      */
-    element<T extends HTMLTextAreaElement>(selector: string): TestTextArea | null;
+    element<T extends HTMLTextAreaElement>(selector: string | Type<any>): TestTextArea | null;
     /**
-     * Gets the first element matching the given CSS selector and wraps it into a TestElement. The actual type
+     * 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.
      * <p>Usage:</p>
      * <code>
      * const testElement: TestSelect | null = tester.element&lt;HTMLSelectElement>('.selector');
      * </code>
-     * @param selector a CSS selector
+     * @param selector a CSS or directive selector
      * @returns the wrapped element, or null if no element matches the selector.
      */
-    element<T extends HTMLSelectElement>(selector: string): TestSelect | null;
+    element<T extends HTMLSelectElement>(selector: string | Type<any>): TestSelect | null;
     /**
-     * Gets the first element matching the given CSS selector and wraps it into a TestElement. The actual type
+     * 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.
      * <p>Usage:</p>
      * <code>
      * const testElement: TestButton | null = tester.element&lt;HTMLButtonElement>('.selector');
      * </code>
-     * @param selector a CSS selector
+     * @param selector a CSS or directive selector
      * @returns the wrapped element, or null if no element matches the selector.
      */
-    element<T extends HTMLButtonElement>(selector: string): TestButton | null;
+    element<T extends HTMLButtonElement>(selector: string | Type<any>): TestButton | null;
     /**
-     * Gets the first element matching the given CSS selector and wraps it into a TestElement. The actual type
+     * 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.
      * <p>Usage:</p>
      * <code>
      * const testElement: TestHtmlElement&lt;HTMLDivElement> | null = tester.element&lt;HTMLDivElement>('.selector');
      * </code>
-     * @param selector a CSS selector
+     * @param selector a CSS or directive selector
      * @returns the wrapped element, or null if no element matches the selector.
      */
-    element<T extends HTMLElement>(selector: string): TestHtmlElement<T> | null;
+    element<T extends HTMLElement>(selector: string | Type<any>): TestHtmlElement<T> | null;
     /**
-     * Gets the first element matching the given CSS selector and wraps it into a TestElement. The actual type
+     * 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.
      * <p>Usage:</p>
      * <code>
      * const testElement: TestElement&lt;SVGLineElement> | null = tester.element&lt;SVGLineElement>('.selector');
      * </code>
-     * @param selector a CSS selector
+     * @param selector a CSS or directive selector
      * @returns the wrapped element, or null if no element matches the selector.
      */
-    element<T extends Element>(selector: string): TestElement<T> | null;
+    element<T extends Element>(selector: string | Type<any>): TestElement<T> | null;
     /**
      * Gets all the elements matching the given CSS 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
@@ -175,41 +175,41 @@ export declare class TestElement<E extends Element = Element> {
      */
     elements<K extends keyof SVGElementTagNameMap>(selector: K): Array<TestElement<SVGElementTagNameMap[K]>>;
     /**
-     * Gets all the elements matching the given CSS selector and wraps them into a TestElement. The actual type
+     * 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.
      * <p>Usage:</p>
      * <code>
      * const testElements: Array&lt;TestElement> = tester.elements('.selector');
      * </code>
-     * @param selector a CSS selector
+     * @param selector a CSS or directive selector
      * @returns the array of matched elements, empty if no element was matched
      */
-    elements(selector: string): Array<TestElement>;
+    elements(selector: string | Type<any>): Array<TestElement>;
     /**
-     * Gets all the elements matching the given CSS selector and wraps them into a TestElement. The actual type
+     * 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.
      * <p>Usage:</p>
      * <code>
      * const testElements: Array&lt;TestInput> = tester.elements&lt;HTMLInputElement>('.selector');
      * </code>
-     * @param selector a CSS selector
+     * @param selector a CSS or directive selector
      * @returns the array of matched elements, empty if no element was matched
      */
-    elements<T extends HTMLInputElement>(selector: string): Array<TestInput>;
+    elements<T extends HTMLInputElement>(selector: string | Type<any>): Array<TestInput>;
     /**
-     * Gets all the elements matching the given CSS selector and wraps them into a TestElement. The actual type
+     * 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.
      * <p>Usage:</p>
      * <code>
      * const testElements: Array&lt;TestTextArea> = tester.elements&lt;HTMLTextAreaElement>('.selector');
      * </code>
-     * @param selector a CSS selector
+     * @param selector a CSS or directive selector
      * @returns the array of matched elements, empty if no element was matched
      */
-    elements<T extends HTMLTextAreaElement>(selector: string): Array<TestTextArea>;
+    elements<T extends HTMLTextAreaElement>(selector: string | Type<any>): Array<TestTextArea>;
     /**
      * Gets all the elements matching the given CSS 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
@@ -218,69 +218,107 @@ export declare class TestElement<E extends Element = Element> {
      * <code>
      * const testElements: Array&lt;TestButton> = tester.elements&lt;HTMLButtonElement>('.selector');
      * </code>
-     * @param selector a CSS selector
+     * @param selector a CSS or directive selector
      * @returns the array of matched elements, empty if no element was matched
      */
-    elements<T extends HTMLButtonElement>(selector: string): Array<TestButton>;
+    elements<T extends HTMLButtonElement>(selector: string | Type<any>): Array<TestButton>;
     /**
-     * Gets all the elements matching the given CSS selector and wraps them into a TestElement. The actual type
+     * 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.
      * <p>Usage:</p>
      * <code>
      * const testElements: Array&lt;TestSelect> = tester.elements<HTMLSelectElement>('.selector');
      * </code>
-     * @param selector a CSS selector
+     * @param selector a CSS or directive selector
      * @returns the array of matched elements, empty if no element was matched
      */
-    elements<T extends HTMLSelectElement>(selector: string): Array<TestSelect>;
+    elements<T extends HTMLSelectElement>(selector: string | Type<any>): Array<TestSelect>;
     /**
-     * Gets all the elements matching the given CSS selector and wraps them into a TestElement. The actual type
+     * 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.
      * <p>Usage:</p>
      * <code>
      * const testElements: Array&lt;TestHtmlElement&lt;HTMLDivElement>> = tester.elements&lt;HTMLDivElement>('.selector');
      * </code>
-     * @param selector a CSS selector
+     * @param selector a CSS or directive selector
      * @returns the array of matched elements, empty if no element was matched
      */
-    elements<T extends HTMLElement>(selector: string): Array<TestHtmlElement<T>>;
+    elements<T extends HTMLElement>(selector: string | Type<any>): Array<TestHtmlElement<T>>;
     /**
-     * Gets all the elements matching the given CSS selector and wraps them into a TestElement. The actual type
+     * 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.
      * <p>Usage:</p>
      * <code>
      * const testElements: Array&lt;TestElement&lt;SVGLineElement>> = tester.elements&lt;SVGLineElement>('.selector');
      * </code>
-     * @param selector a CSS selector
+     * @param selector a CSS or directive selector
      * @returns the array of matched elements, empty if no element was matched
      */
-    elements<T extends Element>(selector: string): Array<TestElement<T>>;
+    elements<T extends Element>(selector: string | Type<any>): Array<TestElement<T>>;
     /**
      * 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 selector
+     * @param selector a CSS or directive selector
      * @returns the wrapped input, or null if no element was matched
      */
-    input(selector: string): TestInput | null;
+    input(selector: string | Type<any>): TestInput | null;
     /**
      * 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 selector
+     * @param selector a CSS or directive selector
      * @returns the wrapped select, or null if no element was matched
      */
-    select(selector: string): TestSelect | null;
+    select(selector: string | Type<any>): TestSelect | null;
     /**
      * Gets the first textarea matched by the given selector
-     * @param selector a CSS 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: string): TestTextArea | null;
+    textarea(selector: string | Type<any>): TestTextArea | null;
     /**
      * 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 selector
+     * @param selector a CSS or directive selector
      * @returns the wrapped button, or null if no element was matched
      */
-    button(selector: string): TestButton | null;
+    button(selector: string | Type<any>): TestButton | null;
+    /**
+     * Gets the first directive matching the given component directive selector and returns its component instance
+     * @param selector the selector of a component directive
+     */
+    component<R>(selector: Type<R>): R;
+    /**
+     * Gets the directives matching the given component directive selector and returns their component instance
+     * @param selector the selector of a component directive
+     */
+    components<R>(selector: Type<R>): Array<R>;
+    /**
+     * 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<R>(selector: string | Type<any>, token: ProviderToken<R>): R | 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<R>(selector: string | Type<any>, token: ProviderToken<R>): Array<R | 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<E extends TestElement>(selector: string | Type<any>, customTestElementType: Type<E>): E | null;
+    /**
+     * 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<E extends TestElement>(selector: string | Type<any>, customTestElementType: Type<E>): Array<E>;
 }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "ngx-speculoos",
-  "version": "6.0.0",
+  "version": "7.2.0",
   "description": "Helps writing Angular unit tests",
   "peerDependencies": {
-    "@angular/core": "^12.0.0",
-    "@angular/platform-browser": "^12.0.0",
-    "@angular/router": "^12.0.0",
-    "rxjs": "^6.5.4"
+    "@angular/core": "^13.0.0",
+    "@angular/platform-browser": "^13.0.0",
+    "@angular/router": "^13.0.0",
+    "rxjs": "^7.4.0"
   },
   "license": "MIT",
   "repository": {
@@ -25,13 +25,26 @@
     "save": "devDependencies"
   },
   "dependencies": {
-    "tslib": "2.2.0"
+    "tslib": "2.3.1"
   },
-  "main": "bundles/ngx-speculoos.umd.js",
-  "module": "fesm2015/ngx-speculoos.js",
-  "es2015": "fesm2015/ngx-speculoos.js",
-  "esm2015": "esm2015/ngx-speculoos.js",
-  "fesm2015": "fesm2015/ngx-speculoos.js",
+  "module": "fesm2015/ngx-speculoos.mjs",
+  "es2020": "fesm2020/ngx-speculoos.mjs",
+  "esm2020": "esm2020/ngx-speculoos.mjs",
+  "fesm2020": "fesm2020/ngx-speculoos.mjs",
+  "fesm2015": "fesm2015/ngx-speculoos.mjs",
   "typings": "ngx-speculoos.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./ngx-speculoos.d.ts",
+      "esm2020": "./esm2020/ngx-speculoos.mjs",
+      "es2020": "./fesm2020/ngx-speculoos.mjs",
+      "es2015": "./fesm2015/ngx-speculoos.mjs",
+      "node": "./fesm2015/ngx-speculoos.mjs",
+      "default": "./fesm2020/ngx-speculoos.mjs"
+    }
+  },
   "sideEffects": false
 }

package/public_api.d.ts

@@ -8,3 +8,4 @@ export * from './lib/test-select';
 export * from './lib/test-textarea';
 export * from './lib/route';
 export * from './lib/matchers';
+export * from './lib/mock';