@dbg-riskit/angular-testing 9999.9999.9999-rc.41185 → 9999.9999.9999-rc.436399

package/esm2022/lib/definitions/download.menu.page.mjs

@@ -0,0 +1,97 @@
+import { Component } from '@angular/core';
+import { MatMenuItem, MatMenuTrigger } from '@angular/material/menu';
+import { By } from '@angular/platform-browser';
+import { CSVFileDownloadDirective, FileDownloadDirective } from '@dbg-riskit/angular-file';
+import * as fileSaver from 'file-saver';
+import { click } from '../events';
+import { Page } from './page.base';
+import * as i0 from "@angular/core";
+import * as i1 from "@dbg-riskit/angular-file";
+export class CSVDownloadMenuPage extends Page {
+    constructor(fixture) {
+        super(fixture);
+    }
+    get downloadWindowsLink() {
+        // Open the menu first
+        click(this.debugElement.query(By.directive(MatMenuTrigger)));
+        this.detectChanges(500);
+        return new DownloadLink(this.debugElement.queryAll(By.directive(MatMenuItem))[0], this);
+    }
+    get downloadUnixLink() {
+        // Open the menu first
+        click(this.debugElement.query(By.directive(MatMenuTrigger)));
+        this.detectChanges(500);
+        return new DownloadLink(this.debugElement.queryAll(By.directive(MatMenuItem))[1], this);
+    }
+}
+export class DownloadLink {
+    element;
+    page;
+    _blobSpy;
+    _saveBlobSpy;
+    constructor(element, page) {
+        this.element = element;
+        this.page = page;
+    }
+    click() {
+        this.setupBlobConstructorSpy();
+        this.setupSaveBlobSpy();
+        click(this.element);
+        this.page.detectChanges();
+    }
+    get blobSpy() {
+        this.setupBlobConstructorSpy();
+        return this._blobSpy;
+    }
+    setupBlobConstructorSpy() {
+        if (!this._blobSpy) {
+            let downloadDirective;
+            try {
+                downloadDirective = this.element.injector.get(CSVFileDownloadDirective);
+            }
+            catch (_) {
+                downloadDirective = this.element.injector.get(FileDownloadDirective);
+            }
+            this._blobSpy = spyOn(downloadDirective, 'createBlob').and.callThrough();
+        }
+    }
+    get saveSpy() {
+        this.setupSaveBlobSpy();
+        return this._saveBlobSpy;
+    }
+    setupSaveBlobSpy() {
+        if (!this._saveBlobSpy) {
+            this._saveBlobSpy = spyOn(fileSaver, 'saveAs');
+        }
+    }
+}
+export class DownloadTestComponent {
+    data;
+    contentType;
+    filename;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DownloadTestComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: DownloadTestComponent, selector: "ng-component", ngImport: i0, template: `
+        <a [risk-download]="data"
+           [risk-download-content-type]="contentType"
+           [risk-download-filename]="filename">Download</a>
+    `, isInline: true, dependencies: [{ kind: "directive", type: i1.FileDownloadDirective, selector: "[risk-download]", inputs: ["risk-download", "risk-download-content-type", "risk-download-filename"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DownloadTestComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+        <a [risk-download]="data"
+           [risk-download-content-type]="contentType"
+           [risk-download-filename]="filename">Download</a>
+    `
+                }]
+        }] });
+export class DownloadTestComponentPage extends Page {
+    constructor(fixture) {
+        super(fixture);
+    }
+    get downloadLink() {
+        return new DownloadLink(this.debugElement.query(By.directive(FileDownloadDirective)), this);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/definitions/highlighter.directive.page.mjs

@@ -0,0 +1,37 @@
+import { Component } from '@angular/core';
+import { By } from '@angular/platform-browser';
+import { HighlighterDirective } from '@dbg-riskit/angular-datatable';
+import { Page } from './page.base';
+import * as i0 from "@angular/core";
+import * as i1 from "@dbg-riskit/angular-datatable";
+export class HighLighterDirectiveTestComponent {
+    context;
+    trackBy(index, row) {
+        return row.rowData;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HighLighterDirectiveTestComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: HighLighterDirectiveTestComponent, selector: "ng-component", ngImport: i0, template: `
+        <div [risk-data-table-highlighter]="trackBy" [risk-data-table-highlighter-context]="context"></div>`, isInline: true, dependencies: [{ kind: "directive", type: i1.HighlighterDirective, selector: "[risk-data-table-highlighter]", inputs: ["risk-data-table-highlighter", "risk-data-table-highlighter-context"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HighLighterDirectiveTestComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+        <div [risk-data-table-highlighter]="trackBy" [risk-data-table-highlighter-context]="context"></div>`
+                }]
+        }] });
+export class HighLighterDirectivePage extends Page {
+    constructor(fixture) {
+        super(fixture);
+    }
+    get highlightedElement() {
+        return this.debugElement.query(By.directive(HighlighterDirective));
+    }
+    get classList() {
+        return this.highlightedElement.nativeElement.classList;
+    }
+    get highlighter() {
+        return this.highlightedElement.injector.get(HighlighterDirective);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/definitions/layout.component.page.mjs

@@ -0,0 +1,95 @@
+import { Component } from '@angular/core';
+import { MatSidenav, MatSidenavContainer } from '@angular/material/sidenav';
+import { MatToolbar } from '@angular/material/toolbar';
+import { By } from '@angular/platform-browser';
+import { LayoutComponent } from '@dbg-riskit/angular-view';
+import { ByUtil } from '../by.util';
+import { Page } from './page.base';
+import * as i0 from "@angular/core";
+import * as i1 from "@dbg-riskit/angular-view";
+export class LayoutComponentDefinition {
+    debugElement;
+    page;
+    constructor(debugElement, page) {
+        this.debugElement = debugElement;
+        this.page = page;
+    }
+    get component() {
+        return this.debugElement.componentInstance;
+    }
+    get headToolbar() {
+        return this.debugElement.query(ByUtil.and(By.directive(MatToolbar), By.css('.mat-elevation-z2')));
+    }
+    get logo() {
+        return this.headToolbar.query(By.css('.risk-layout-logo'));
+    }
+    get menu() {
+        return this.headToolbar.queryAll(ByUtil.or(By.css('[menu-horizontal]'), By.css('risk-layout-horizontal')));
+    }
+    get sideNavContainer() {
+        return this.debugElement.query(By.directive(MatSidenavContainer));
+    }
+    get sideNav() {
+        return this.sideNavContainer.query(By.directive(MatSidenav));
+    }
+    openSideNav() {
+        this.sideNav.componentInstance.open();
+        this.page.advanceAndDetectChanges();
+    }
+    closeSideNav() {
+        this.sideNav.componentInstance.close();
+        this.page.advanceAndDetectChanges(1);
+    }
+    get sideNavMenu() {
+        return this.sideNav.queryAll(ByUtil.or(By.css('[menu-vertical]'), By.css('risk-layout-vertical')));
+    }
+    get content() {
+        return this.sideNavContainer.query(By.css('.risk-layout-content'));
+    }
+}
+export class TestLayoutComponentHostPage extends Page {
+    get layoutComponent() {
+        return new LayoutComponentDefinition(this.debugElement.query(By.directive(LayoutComponent)), this);
+    }
+}
+export class TestLayoutHostComponent {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TestLayoutHostComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TestLayoutHostComponent, selector: "ng-component", ngImport: i0, template: `
+        <risk-layout>
+            <!--  menu-horizontal -->
+            <risk-layout-horizontal>
+                HorizontalMenu
+            </risk-layout-horizontal>
+            <!--  menu-horizontal -->
+
+            <!--  menu-vertical -->
+            <risk-layout-vertical>
+                Vertical menu
+            </risk-layout-vertical>
+
+            <span>Content</span>
+        </risk-layout>
+    `, isInline: true, dependencies: [{ kind: "component", type: i1.LayoutComponent, selector: "risk-layout", inputs: ["smallScreenMenuVisible", "smallScreenWidth", "footerVisible", "toolbarBackgroundColor", "backgroundColor"] }, { kind: "directive", type: i1.VerticalLayoutDirective, selector: "risk-layout-vertical" }, { kind: "directive", type: i1.HorizontalLayoutDirective, selector: "risk-layout-horizontal" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TestLayoutHostComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+        <risk-layout>
+            <!--  menu-horizontal -->
+            <risk-layout-horizontal>
+                HorizontalMenu
+            </risk-layout-horizontal>
+            <!--  menu-horizontal -->
+
+            <!--  menu-vertical -->
+            <risk-layout-vertical>
+                Vertical menu
+            </risk-layout-vertical>
+
+            <span>Content</span>
+        </risk-layout>
+    `
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/definitions/link.definition.mjs

@@ -0,0 +1,21 @@
+import { click } from '../events';
+import { RouterLinkStubDirective } from '../stubs/router/router.link.stub';
+export class LinkDefinition {
+    page;
+    link;
+    constructor(page, link) {
+        this.page = page;
+        this.link = link;
+    }
+    get stub() {
+        return this.link.injector.get(RouterLinkStubDirective);
+    }
+    get text() {
+        return this.link.nativeElement.textContent.trim();
+    }
+    click() {
+        click(this.link.nativeElement);
+        this.page.advanceAndDetectChanges();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGluay5kZWZpbml0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGtnL2RiZy1yaXNraXQvYW5ndWxhci10ZXN0aW5nL3NyYy9saWIvZGVmaW5pdGlvbnMvbGluay5kZWZpbml0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBQyxLQUFLLEVBQUMsTUFBTSxXQUFXLENBQUM7QUFDaEMsT0FBTyxFQUFDLHVCQUF1QixFQUFDLE1BQU0sa0NBQWtDLENBQUM7QUFHekUsTUFBTSxPQUFPLGNBQWM7SUFFSTtJQUF3QjtJQUFuRCxZQUEyQixJQUFlLEVBQVMsSUFBa0I7UUFBMUMsU0FBSSxHQUFKLElBQUksQ0FBVztRQUFTLFNBQUksR0FBSixJQUFJLENBQWM7SUFDckUsQ0FBQztJQUVELElBQVcsSUFBSTtRQUNYLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLHVCQUF1QixDQUFDLENBQUM7SUFDM0QsQ0FBQztJQUVELElBQVcsSUFBSTtRQUNYLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsV0FBVyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3RELENBQUM7SUFFTSxLQUFLO1FBQ1IsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDL0IsSUFBSSxDQUFDLElBQUksQ0FBQyx1QkFBdUIsRUFBRSxDQUFDO0lBQ3hDLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RGVidWdFbGVtZW50fSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHtjbGlja30gZnJvbSAnLi4vZXZlbnRzJztcbmltcG9ydCB7Um91dGVyTGlua1N0dWJEaXJlY3RpdmV9IGZyb20gJy4uL3N0dWJzL3JvdXRlci9yb3V0ZXIubGluay5zdHViJztcbmltcG9ydCB7UGFnZX0gZnJvbSAnLi9wYWdlLmJhc2UnO1xuXG5leHBvcnQgY2xhc3MgTGlua0RlZmluaXRpb24ge1xuXG4gICAgcHVibGljIGNvbnN0cnVjdG9yKHByaXZhdGUgcGFnZTogUGFnZTxhbnk+LCBwdWJsaWMgbGluazogRGVidWdFbGVtZW50KSB7XG4gICAgfVxuXG4gICAgcHVibGljIGdldCBzdHViKCk6IFJvdXRlckxpbmtTdHViRGlyZWN0aXZlIHtcbiAgICAgICAgcmV0dXJuIHRoaXMubGluay5pbmplY3Rvci5nZXQoUm91dGVyTGlua1N0dWJEaXJlY3RpdmUpO1xuICAgIH1cblxuICAgIHB1YmxpYyBnZXQgdGV4dCgpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gdGhpcy5saW5rLm5hdGl2ZUVsZW1lbnQudGV4dENvbnRlbnQudHJpbSgpO1xuICAgIH1cblxuICAgIHB1YmxpYyBjbGljaygpIHtcbiAgICAgICAgY2xpY2sodGhpcy5saW5rLm5hdGl2ZUVsZW1lbnQpO1xuICAgICAgICB0aGlzLnBhZ2UuYWR2YW5jZUFuZERldGVjdENoYW5nZXMoKTtcbiAgICB9XG59XG4iXX0=

package/esm2022/lib/definitions/message.def.mjs

@@ -0,0 +1,16 @@
+import { MatCard } from '@angular/material/card';
+import { By } from '@angular/platform-browser';
+export class MessageComponentDef {
+    debugElement;
+    constructor(debugElement) {
+        this.debugElement = debugElement;
+        if (debugElement == null) {
+            throw new Error('Debug element not found!');
+        }
+    }
+    get text() {
+        return this.debugElement.query(By.directive(MatCard)).nativeElement.textContent.replace(/\n\s*/g, ' ')
+            .replace(/\r\s*/g, ' ').trim();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZS5kZWYuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wa2cvZGJnLXJpc2tpdC9hbmd1bGFyLXRlc3Rpbmcvc3JjL2xpYi9kZWZpbml0aW9ucy9tZXNzYWdlLmRlZi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUMsT0FBTyxFQUFDLE1BQU0sd0JBQXdCLENBQUM7QUFDL0MsT0FBTyxFQUFDLEVBQUUsRUFBQyxNQUFNLDJCQUEyQixDQUFDO0FBRTdDLE1BQU0sT0FBTyxtQkFBbUI7SUFFRjtJQUExQixZQUEwQixZQUEwQjtRQUExQixpQkFBWSxHQUFaLFlBQVksQ0FBYztRQUNoRCxJQUFJLFlBQVksSUFBSSxJQUFJLEVBQUU7WUFDdEIsTUFBTSxJQUFJLEtBQUssQ0FBQywwQkFBMEIsQ0FBQyxDQUFDO1NBQy9DO0lBQ0wsQ0FBQztJQUVELElBQVcsSUFBSTtRQUNYLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLGFBQWEsQ0FBQyxXQUFXLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRSxHQUFHLENBQUM7YUFDakcsT0FBTyxDQUFDLFFBQVEsRUFBRSxHQUFHLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUN2QyxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RlYnVnRWxlbWVudH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge01hdENhcmR9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2NhcmQnO1xuaW1wb3J0IHtCeX0gZnJvbSAnQGFuZ3VsYXIvcGxhdGZvcm0tYnJvd3Nlcic7XG5cbmV4cG9ydCBjbGFzcyBNZXNzYWdlQ29tcG9uZW50RGVmIHtcblxuICAgIHB1YmxpYyBjb25zdHJ1Y3RvcihwdWJsaWMgZGVidWdFbGVtZW50OiBEZWJ1Z0VsZW1lbnQpIHtcbiAgICAgICAgaWYgKGRlYnVnRWxlbWVudCA9PSBudWxsKSB7XG4gICAgICAgICAgICB0aHJvdyBuZXcgRXJyb3IoJ0RlYnVnIGVsZW1lbnQgbm90IGZvdW5kIScpO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgcHVibGljIGdldCB0ZXh0KCk6IHN0cmluZyB7XG4gICAgICAgIHJldHVybiB0aGlzLmRlYnVnRWxlbWVudC5xdWVyeShCeS5kaXJlY3RpdmUoTWF0Q2FyZCkpLm5hdGl2ZUVsZW1lbnQudGV4dENvbnRlbnQucmVwbGFjZSgvXFxuXFxzKi9nLCAnICcpXG4gICAgICAgICAgICAucmVwbGFjZSgvXFxyXFxzKi9nLCAnICcpLnRyaW0oKTtcbiAgICB9XG59XG4iXX0=

package/esm2022/lib/definitions/message.page.mjs

@@ -0,0 +1,66 @@
+import { Component } from '@angular/core';
+import { By } from '@angular/platform-browser';
+import { RISK_ERROR_SELECTOR, RISK_GOOD_SELECTOR, RISK_INFO_SELECTOR, RISK_INITIAL_LOAD_SELECTOR, RISK_MESSAGE_SELECTOR, RISK_NO_DATA_SELECTOR, RISK_UPDATE_FAILED_SELECTOR, RISK_WARN_SELECTOR } from '@dbg-riskit/angular-view';
+import { MessageComponentDef } from './message.def';
+import { Page } from './page.base';
+import * as i0 from "@angular/core";
+import * as i1 from "@dbg-riskit/angular-view";
+export class TestMessageHostComponent {
+    message = 'custom message';
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TestMessageHostComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TestMessageHostComponent, selector: "ng-component", ngImport: i0, template: `
+        <risk-error [message]="message"></risk-error>
+        <risk-good [message]="message"></risk-good>
+        <risk-info [message]="message"></risk-info>
+        <risk-message [message]="message"></risk-message>
+        <risk-warn [message]="message"></risk-warn>
+        <risk-initial-load [message]="message"></risk-initial-load>
+        <risk-update-failed [message]="message"></risk-update-failed>
+        <risk-no-data [message]="message"></risk-no-data>
+    `, isInline: true, dependencies: [{ kind: "component", type: i1.MessageComponent, selector: "risk-error, risk-good, risk-info, risk-message, risk-warn, risk-initial-load, risk-no-data, risk-update-failed", inputs: ["message"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TestMessageHostComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+        <risk-error [message]="message"></risk-error>
+        <risk-good [message]="message"></risk-good>
+        <risk-info [message]="message"></risk-info>
+        <risk-message [message]="message"></risk-message>
+        <risk-warn [message]="message"></risk-warn>
+        <risk-initial-load [message]="message"></risk-initial-load>
+        <risk-update-failed [message]="message"></risk-update-failed>
+        <risk-no-data [message]="message"></risk-no-data>
+    `
+                }]
+        }] });
+export class MessageHostedPage extends Page {
+    constructor(fixture) {
+        super(fixture);
+    }
+    get error() {
+        return new MessageComponentDef(this.debugElement.query(By.css(RISK_ERROR_SELECTOR)));
+    }
+    get good() {
+        return new MessageComponentDef(this.debugElement.query(By.css(RISK_GOOD_SELECTOR)));
+    }
+    get info() {
+        return new MessageComponentDef(this.debugElement.query(By.css(RISK_INFO_SELECTOR)));
+    }
+    get message() {
+        return new MessageComponentDef(this.debugElement.query(By.css(RISK_MESSAGE_SELECTOR)));
+    }
+    get warn() {
+        return new MessageComponentDef(this.debugElement.query(By.css(RISK_WARN_SELECTOR)));
+    }
+    get initialLoad() {
+        return new MessageComponentDef(this.debugElement.query(By.css(RISK_INITIAL_LOAD_SELECTOR)));
+    }
+    get noData() {
+        return new MessageComponentDef(this.debugElement.query(By.css(RISK_NO_DATA_SELECTOR)));
+    }
+    get updateFailed() {
+        return new MessageComponentDef(this.debugElement.query(By.css(RISK_UPDATE_FAILED_SELECTOR)));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/definitions/page.base.mjs

@@ -0,0 +1,67 @@
+import { discardPeriodicTasks, tick } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { RISK_INITIAL_LOAD_SELECTOR, RISK_NO_DATA_SELECTOR } from '@dbg-riskit/angular-view';
+import { FAKE_HTTP_ASYNC_TIMEOUT } from '../stubs/http.service.stub';
+import { MessageComponentDef } from './message.def';
+export class Page {
+    fixture;
+    debugElement;
+    component;
+    _timeOffset = 0;
+    constructor(fixture) {
+        this.fixture = fixture;
+        this.debugElement = fixture.debugElement;
+        this.component = this.debugElement.componentInstance;
+    }
+    detectChanges(millis = 0) {
+        this.fixture.detectChanges();
+        tick(millis);
+        this._timeOffset += millis;
+    }
+    advanceAndDetectChanges(millis = 0) {
+        tick(millis);
+        this._timeOffset += millis;
+        this.detectChanges();
+    }
+    advanceHTTP() {
+        this.advanceAndDetectChanges(FAKE_HTTP_ASYNC_TIMEOUT);
+    }
+    advanceAndDetectChangesUsingOffset(millis) {
+        this.advanceAndDetectChanges(millis - this._timeOffset);
+        this.resetTimeOffset();
+    }
+    resetTimeOffset() {
+        this._timeOffset = 0;
+    }
+    destroy() {
+        this.fixture.destroy();
+        try {
+            // Move a lot into fututre ;)
+            tick(60 * 60 * 1000);
+            discardPeriodicTasks();
+        }
+        catch (ignore) {
+            // Nothing to do...
+        }
+    }
+}
+export class PageWithLoading extends Page {
+    constructor(fixture) {
+        super(fixture);
+    }
+    get initialLoadComponent() {
+        const element = this.debugElement.query(By.css(RISK_INITIAL_LOAD_SELECTOR));
+        if (element) {
+            return new MessageComponentDef(element);
+        }
+        return null;
+    }
+    get noDataComponent() {
+        const element = this.debugElement.query(By.css(RISK_NO_DATA_SELECTOR));
+        if (element) {
+            return new MessageComponentDef(element);
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/stubs/auth/auth.routing.flow.service.stub.mjs

@@ -0,0 +1,38 @@
+import { Inject, Injectable } from '@angular/core';
+import { AUTH_CONFIG, AuthRoutingFlowService } from '@dbg-riskit/angular-auth';
+import { AUTH_PROVIDER } from '@dbg-riskit/angular-common';
+import { of } from 'rxjs';
+import { defaultIfEmpty, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@dbg-riskit/angular-auth";
+export const storage = { authRequestedPath: null };
+export class AuthRoutingFlowServiceStub extends AuthRoutingFlowService {
+    authServiceStub;
+    constructor(authServiceStub, authConfig) {
+        super(null, null, { loggedIn: of(null) }, storage, authConfig, null);
+        this.authServiceStub = authServiceStub;
+        // cleanup
+        storage.authRequestedPath = null;
+    }
+    logout(state) {
+        return this.authServiceStub.logout().pipe(defaultIfEmpty(0), map(() => true));
+    }
+    login(username, password) {
+        return this.authServiceStub.directLogin(username, password);
+    }
+    loginViaService() {
+        return this.authServiceStub.loginViaAuthService();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthRoutingFlowServiceStub, deps: [{ token: AUTH_PROVIDER }, { token: AUTH_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthRoutingFlowServiceStub });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthRoutingFlowServiceStub, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.AuthService, decorators: [{
+                    type: Inject,
+                    args: [AUTH_PROVIDER]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [AUTH_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/stubs/auth/auth.service.stub.mjs

@@ -0,0 +1,41 @@
+import { Injectable } from '@angular/core';
+import { AuthService } from '@dbg-riskit/angular-auth';
+import { EMPTY, of } from 'rxjs';
+import { WellKnownServiceStub } from './well.known.service.stub';
+import * as i0 from "@angular/core";
+export class AuthServiceStub extends AuthService {
+    constructor() {
+        super({}, new WellKnownServiceStub(), null, null, null);
+    }
+    user;
+    get loggedIn() {
+        return of(!!this.user);
+    }
+    get userProfile() {
+        return of({
+            name: this.user
+        });
+    }
+    loginViaAuthService() {
+        return of(true);
+    }
+    checkLocationForLoginData() {
+        return of(true);
+    }
+    directLogin(username, password) {
+        this.user = username;
+        this.emitLoginStatusChange(true);
+        return of(true);
+    }
+    logout() {
+        this.emitLoginStatusChange(false);
+        delete this.user;
+        return EMPTY;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthServiceStub, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthServiceStub });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthServiceStub, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/stubs/auth/well.known.service.stub.mjs

@@ -13,10 +13,10 @@ export class WellKnownServiceStub {
     get wellKnown() {
         return of(WELL_KNOWN);
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: WellKnownServiceStub, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: WellKnownServiceStub });
 }
-WellKnownServiceStub.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: WellKnownServiceStub, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-WellKnownServiceStub.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: WellKnownServiceStub });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.6", ngImport: i0, type: WellKnownServiceStub, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: WellKnownServiceStub, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2VsbC5rbm93bi5zZXJ2aWNlLnN0dWIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wa2cvZGJnLXJpc2tpdC9hbmd1bGFyLXRlc3Rpbmcvc3JjL2xpYi9zdHVicy9hdXRoL3dlbGwua25vd24uc2VydmljZS5zdHViLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFJekMsT0FBTyxFQUFhLEVBQUUsRUFBQyxNQUFNLE1BQU0sQ0FBQzs7QUFFcEMsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFjO0lBQ2pDLFNBQVMsRUFBRTtRQUNQLElBQUksRUFBSSxPQUFPO1FBQ2YsS0FBSyxFQUFHLFFBQVE7UUFDaEIsTUFBTSxFQUFFLFNBQVM7S0FDcEI7SUFDRCxNQUFNLEVBQUssV0FBVztDQUN6QixDQUFDO0FBR0YsTUFBTSxPQUFPLG9CQUFvQjtJQUM3QixJQUFXLFNBQVM7UUFDaEIsT0FBTyxFQUFFLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDMUIsQ0FBQzs7aUhBSFEsb0JBQW9CO3FIQUFwQixvQkFBb0I7MkZBQXBCLG9CQUFvQjtrQkFEaEMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW5qZWN0YWJsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7V2VsbEtub3dufSBmcm9tICdAZGJnLXJpc2tpdC9hbmd1bGFyLWF1dGgnO1xuXG5pbXBvcnQge09ic2VydmFibGUsIG9mfSBmcm9tICdyeGpzJztcblxuZXhwb3J0IGNvbnN0IFdFTExfS05PV046IFdlbGxLbm93biA9IHtcbiAgICBlbmRwb2ludHM6IHtcbiAgICAgICAgYXV0aCAgOiAnL2F1dGgnLFxuICAgICAgICB0b2tlbiA6ICcvdG9rZW4nLFxuICAgICAgICBsb2dvdXQ6ICcvbG9nb3V0J1xuICAgIH0sXG4gICAgaXNzdWVyICAgOiAncmlzay1hdXRoJ1xufTtcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFdlbGxLbm93blNlcnZpY2VTdHViIHtcbiAgICBwdWJsaWMgZ2V0IHdlbGxLbm93bigpOiBPYnNlcnZhYmxlPFdlbGxLbm93bj4ge1xuICAgICAgICByZXR1cm4gb2YoV0VMTF9LTk9XTik7XG4gICAgfVxuXG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2VsbC5rbm93bi5zZXJ2aWNlLnN0dWIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wa2cvZGJnLXJpc2tpdC9hbmd1bGFyLXRlc3Rpbmcvc3JjL2xpYi9zdHVicy9hdXRoL3dlbGwua25vd24uc2VydmljZS5zdHViLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFJekMsT0FBTyxFQUFhLEVBQUUsRUFBQyxNQUFNLE1BQU0sQ0FBQzs7QUFFcEMsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFjO0lBQ2pDLFNBQVMsRUFBRTtRQUNQLElBQUksRUFBSSxPQUFPO1FBQ2YsS0FBSyxFQUFHLFFBQVE7UUFDaEIsTUFBTSxFQUFFLFNBQVM7S0FDcEI7SUFDRCxNQUFNLEVBQUssV0FBVztDQUN6QixDQUFDO0FBR0YsTUFBTSxPQUFPLG9CQUFvQjtJQUM3QixJQUFXLFNBQVM7UUFDaEIsT0FBTyxFQUFFLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDMUIsQ0FBQzt3R0FIUSxvQkFBb0I7NEdBQXBCLG9CQUFvQjs7NEZBQXBCLG9CQUFvQjtrQkFEaEMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW5qZWN0YWJsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7V2VsbEtub3dufSBmcm9tICdAZGJnLXJpc2tpdC9hbmd1bGFyLWF1dGgnO1xuXG5pbXBvcnQge09ic2VydmFibGUsIG9mfSBmcm9tICdyeGpzJztcblxuZXhwb3J0IGNvbnN0IFdFTExfS05PV046IFdlbGxLbm93biA9IHtcbiAgICBlbmRwb2ludHM6IHtcbiAgICAgICAgYXV0aCAgOiAnL2F1dGgnLFxuICAgICAgICB0b2tlbiA6ICcvdG9rZW4nLFxuICAgICAgICBsb2dvdXQ6ICcvbG9nb3V0J1xuICAgIH0sXG4gICAgaXNzdWVyICAgOiAncmlzay1hdXRoJ1xufTtcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFdlbGxLbm93blNlcnZpY2VTdHViIHtcbiAgICBwdWJsaWMgZ2V0IHdlbGxLbm93bigpOiBPYnNlcnZhYmxlPFdlbGxLbm93bj4ge1xuICAgICAgICByZXR1cm4gb2YoV0VMTF9LTk9XTik7XG4gICAgfVxuXG59XG4iXX0=