ngx-speculoos 6.0.0 → 7.2.0

package/esm2020/lib/test-element.mjs

@@ -0,0 +1,142 @@
+import { TestElementQuerier } from './test-element-querier';
+/**
+ * A wrapped DOM element, providing additional methods and attributes helping with writing tests
+ */
+export 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) {
+        return this.querier.element(selector)?.debugElement?.componentInstance ?? 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) {
+        return this.querier.element(selector)?.debugElement?.injector?.get(token, null) ?? 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 => e.debugElement.injector.get(token, null) ?? 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));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-element.js","sourceRoot":"","sources":["../../../../projects/ngx-speculoos/src/lib/test-element.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { ComponentTester } from './component-tester';\nimport { TestButton } from './test-button';\nimport { TestSelect } from './test-select';\nimport { TestTextArea } from './test-textarea';\nimport { TestInput } from './test-input';\nimport { TestElementQuerier } from './test-element-querier';\nimport { DebugElement, ProviderToken, Type } from '@angular/core';\nimport { TestHtmlElement } from './test-html-element';\n\n/**\n * A wrapped DOM element, providing additional methods and attributes helping with writing tests\n */\nexport class TestElement<E extends Element = Element> {\n  private querier: TestElementQuerier;\n\n  constructor(\n    protected tester: ComponentTester<unknown>,\n    /**\n     * the wrapped debug element\n     */\n    readonly debugElement: DebugElement\n  ) {\n    this.querier = new TestElementQuerier(tester, debugElement);\n  }\n\n  get nativeElement(): E {\n    return this.debugElement.nativeElement;\n  }\n\n  /**\n   * the text content of this element\n   */\n  get textContent(): string | null {\n    return this.nativeElement.textContent;\n  }\n\n  /**\n   * dispatches an event of the given type from the wrapped element, then triggers a change detection\n   */\n  dispatchEventOfType(type: string): void {\n    this.nativeElement.dispatchEvent(new Event(type));\n    this.tester.detectChanges();\n  }\n\n  /**\n   * dispatches the given event from the wrapped element, then triggers a change detection\n   */\n  dispatchEvent(event: Event): void {\n    this.nativeElement.dispatchEvent(event);\n    this.tester.detectChanges();\n  }\n\n  /**\n   * Gets the CSS classes of the wrapped element, as an array\n   */\n  get classes(): Array<string> {\n    return Array.prototype.slice.call(this.nativeElement.classList);\n  }\n\n  /**\n   * Gets the attribute of the wrapped element with the given name\n   * @param name the name of the attribute to get\n   */\n  attr(name: string): string | null {\n    return this.nativeElement.getAttribute(name);\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.querier.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.querier.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.querier.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.querier.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.querier.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.querier.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.querier.element(selector)?.debugElement?.componentInstance ?? null;\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.querier.elements(selector).map(e => e.debugElement.componentInstance);\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.querier.element(selector)?.debugElement?.injector?.get(token, null) ?? null;\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.querier.elements(selector).map(e => e.debugElement.injector.get(token, null) ?? null);\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    const element = this.querier.element(selector);\n    return element && new customTestElementType(this.tester, element.debugElement);\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.querier.elements(selector).map(element => new customTestElementType(this.tester, element.debugElement));\n  }\n}\n"]}

package/{esm2015/public_api.js → esm2020/public_api.mjs}

@@ -12,4 +12,5 @@ export * from './lib/test-select';
 export * from './lib/test-textarea';
 export * from './lib/route';
 export * from './lib/matchers';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1zcGVjdWxvb3Mvc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCOztHQUVHO0FBQ0gsOENBQThDO0FBRTlDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlICovXG4vKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIG5neC1zcGVjdWxvb3NcbiAqL1xuLy8vIDxyZWZlcmVuY2UgcGF0aD1cIi4vamFzbWluZS1tYXRjaGVycy50c1wiIC8+XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudC10ZXN0ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGVzdC1lbGVtZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3Rlc3QtaHRtbC1lbGVtZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3Rlc3QtaW5wdXQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGVzdC1idXR0b24nO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGVzdC1zZWxlY3QnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGVzdC10ZXh0YXJlYSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9yb3V0ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tYXRjaGVycyc7XG4iXX0=
+export * from './lib/mock';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1zcGVjdWxvb3Mvc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCOztHQUVHO0FBQ0gsOENBQThDO0FBRTlDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlICovXG4vKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIG5neC1zcGVjdWxvb3NcbiAqL1xuLy8vIDxyZWZlcmVuY2UgcGF0aD1cIi4vamFzbWluZS1tYXRjaGVycy50c1wiIC8+XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudC10ZXN0ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGVzdC1lbGVtZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3Rlc3QtaHRtbC1lbGVtZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3Rlc3QtaW5wdXQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGVzdC1idXR0b24nO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGVzdC1zZWxlY3QnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGVzdC10ZXh0YXJlYSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9yb3V0ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tYXRjaGVycyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2NrJztcbiJdfQ==