@coolon/angular-ui-powerups 12.4.0-alpha.8 → 12.4.0-alpha.80

package/fesm2015/coolon-angular-ui-powerups-cypress.js

@@ -1,27 +1,48 @@
-import { lang, Mixin } from '@coolon/typescript-utilities';
+import { Stringy, Mixin } from '@coolon/typescript-utilities';
 import * as _ from 'lodash';
+import { __decorate, __metadata } from 'tslib';
+import { Memoize } from '@typescript-plus/fast-memoize-decorator/dist/src';
 import { DefaultUrlSerializer } from '@angular/router';
 
+var ElementLocator;
+(function (ElementLocator) {
+    function findByCssSelector(selector) {
+        return parent => parent.dom().find(selector);
+    }
+    ElementLocator.findByCssSelector = findByCssSelector;
+    function findByTextContent(text) {
+        return parent => parent.dom().contains(text);
+    }
+    ElementLocator.findByTextContent = findByTextContent;
+    function findBySelectorAndTextContent(selector, text) {
+        return parent => parent.dom().contains(selector, text);
+    }
+    ElementLocator.findBySelectorAndTextContent = findBySelectorAndTextContent;
+})(ElementLocator || (ElementLocator = {}));
+
 class PageElement {
-    constructor(parent, selector) {
-        this.parentElementAccessor = parent instanceof PageElement ? () => parent.element() : parent;
-        this.elementAccessStrategy = _.isString(selector) ? {
-            findIn: p => p.find(selector),
-            shouldNotExist: (p) => p.find(selector).should('not.exist')
-        } : selector;
+    constructor(parent, selectorOrLocator) {
+        this.parent = parent;
+        this.domElementLocator = _.isNil(selectorOrLocator) ?
+            this.getDefaultElementLocator() :
+            _.isString(selectorOrLocator) ?
+                ElementLocator.findByCssSelector(selectorOrLocator) :
+                selectorOrLocator;
     }
-    element() {
-        const parent = this.getParentElement();
-        return parent ? this.elementAccessStrategy.findIn(parent) : undefined;
+    getDefaultElementLocator() {
+        return ElementLocator.findByCssSelector(this.getDefaultElementSelector());
     }
-    getParentElement() {
-        return this.parentElementAccessor ? this.parentElementAccessor() : undefined;
+    getDefaultElementSelector() {
+        return Stringy.from(this.constructor.name).dasherize().toString();
+    }
+    dom() {
+        return this.domElementLocator(this.parent);
     }
     find(selector) {
-        return new PageElement(() => this.element(), selector);
+        return new PageElement(this, selector);
     }
     click(text) {
-        text ? this.element().contains(text).click() : this.element().click();
+        text ? this.dom().contains(text).click() : this.dom().click();
     }
     get should() {
         return this.getShoulder(this.getShouldElement());
@@ -30,115 +51,47 @@ class PageElement {
         return element.should.bind(element);
     }
     getShouldElement() {
-        return this.element();
+        return this.dom();
     }
     shouldBeVisible() {
         this.should('be.visible');
     }
     shouldNotBeVisible() {
-        if (!this.elementAccessStrategy.shouldNotExist) {
-            lang.abstractMethod(this.constructor);
-        }
-        this.elementAccessStrategy.shouldNotExist(this.getParentElement());
+        this.should('not.be.visible');
     }
-}
-
-let urlSerialiser = new DefaultUrlSerializer();
-class Path {
-    constructor(segments) {
-        this.segments = segments;
+    shouldExist() {
+        this.dom().should('exist');
     }
-    static extractVisitParameters(url) {
-        var _a, _b;
-        let result = {};
-        const urlTree = urlSerialiser.parse(url);
-        const urlSegments = (_b = (_a = urlTree.root.children.primary) === null || _a === void 0 ? void 0 : _a.segments) !== null && _b !== void 0 ? _b : [];
-        urlSegments === null || urlSegments === void 0 ? void 0 : urlSegments.forEach(s => {
-            result = Object.assign(Object.assign({}, result), s.parameters);
-        });
-        return result;
-    }
-    toUrl(matrixParams) {
-        return this.segments.map(s => s.toUrlPart(matrixParams)).join('/');
+    shouldNotExist() {
+        this.dom().should('not.exist');
     }
 }
-(function (Path) {
-    function setUrlSerialiser(serialiser) {
-        urlSerialiser = serialiser;
-    }
-    Path.setUrlSerialiser = setUrlSerialiser;
-    class Segment {
-        constructor(path, params = {}) {
-            var _a;
-            this.path = path;
-            this.routeId = params === null || params === void 0 ? void 0 : params.routeId;
-            this.visitParams = (_a = params === null || params === void 0 ? void 0 : params.visitParams) !== null && _a !== void 0 ? _a : [];
-        }
-        toUrlPart(params) {
-            let path = this.path;
-            this.visitParams.forEach(p => {
-                const value = params[p];
-                if (value) {
-                    path = `${path};${p}=${value}`;
-                }
-            });
-            if (this.routeId && params[this.routeId]) {
-                path = path + '/' + params[this.routeId];
-            }
-            return path;
-        }
-    }
-    Path.Segment = Segment;
-    class Builder {
-        constructor() {
-            this.segments = [];
-        }
-        segment(name, params) {
-            const builder = new Segment(name, params);
-            this.segments.push(builder);
-            return this;
-        }
-        getPath() {
-            return new Path(this.segments);
-        }
-    }
-    Path.Builder = Builder;
-})(Path || (Path = {}));
 
-class FaceAccessor {
-    constructor(face) {
-        this.face = face;
-    }
-    findIn(parent) {
-        return this.face.text ?
-            parent.contains(`aup-command-face`, this.face.text()) :
-            this.face.icon ?
-                parent.find(`aup-icon[ng-reflect-icon=${this.face.icon()}]`).closest('aup-command-face') :
-                undefined;
-    }
-    shouldNotExist(parent) {
-        return this.face.text ?
-            parent.should('not.contain', `aup-command-face`, this.face.text()) :
-            this.face.icon ?
-                parent.should('not.contain', `aup-icon[ng-reflect-icon=${this.face.icon()}]`) :
-                undefined;
-    }
-}
 class AupCommandFace extends PageElement {
     constructor(parentElement, face) {
-        super(() => parentElement.element(), AupCommandFace.createAccessor(face));
-    }
-    static createAccessor(face) {
-        return new FaceAccessor(face);
+        super(parentElement, AupCommandFace.createElementLocator(face));
+    }
+    static createElementLocator(face) {
+        const locator = parent => {
+            return face.text ?
+                parent.dom().contains(`aup-command-face`, face.text()) :
+                face.icon ?
+                    parent.dom().find(`aup-icon[ng-reflect-icon=${face.icon()}]`).closest('aup-command-face') :
+                    undefined;
+        };
+        // aot compiler doesn't like lambas
+        return locator;
     }
 }
 
 class AupCommand extends PageElement {
-    constructor(parent, face) {
-        const faceAccessor = AupCommandFace.createAccessor(face);
-        super(parent, {
-            findIn(parentElement) {
-                return faceAccessor.findIn(parentElement).closest('aup-command');
+    constructor(parent, faceOrSelector) {
+        super(parent, parentElement => {
+            if (_.isString(faceOrSelector)) {
+                return parentElement.dom().find(faceOrSelector);
+            }
+            else {
+                return AupCommandFace.createElementLocator(faceOrSelector)(parentElement).closest('aup-command');
             }
         });
     }
@@ -151,26 +104,29 @@ class AupCommand extends PageElement {
     shouldBeDisabled() {
         this.getButton().should('be.disabled');
     }
+    shouldBeEnabled() {
+        this.getButton().should('not.be.disabled');
+    }
     getButton() {
-        return this.element().find('button');
+        return this.dom().find('button');
     }
 }
 
 class AupEmptyState extends PageElement {
-    constructor(parent, selector) {
-        super(parent, selector !== null && selector !== void 0 ? selector : 'aup-empty-state');
+    shouldContainText(text) {
+        this.dom().should("contain.text", text);
     }
 }
 
 class AupInput extends PageElement {
     label() {
-        return this.element().find('label');
+        return this.dom().find('label');
     }
     hint() {
-        return this.element().find('mat-hint');
+        return this.dom().find('mat-hint');
     }
     error() {
-        return this.element().find('mat-error');
+        return this.dom().find('mat-error');
     }
     get labelShould() {
         return this.getShoulder(this.label());
@@ -190,11 +146,23 @@ class AupInput extends PageElement {
     errorShouldBe(text) {
         return this.errorShould("have.text", text);
     }
+    shouldBeFocused() {
+        this.input().should("have.focus");
+    }
+    shouldNotBeFocused() {
+        this.input().should("not.have.focus");
+    }
+    type(characters) {
+        this.input().type(characters);
+    }
+    hitEnter() {
+        this.type("{enter}");
+    }
 }
 (function (AupInput) {
     class HtmlInput extends AupInput {
         input() {
-            return this.element().find('input');
+            return this.dom().find('input');
         }
         clear() {
             this.input().clear();
@@ -215,7 +183,7 @@ class AupInput extends PageElement {
             return this.input();
         }
         input() {
-            return this.element().find('textarea');
+            return this.dom().find('textarea');
         }
         clear() {
             this.input().clear();
@@ -230,6 +198,46 @@ class AupInput extends PageElement {
     AupInput.TextAreaInput = TextAreaInput;
 })(AupInput || (AupInput = {}));
 
+class AupPopupMenuPanel extends PageElement {
+}
+
+class AupAbstractPopupMenu extends PageElement {
+    constructor(parent, locator) {
+        super(parent, locator);
+        this.popup = new AupPopupMenuPanel(this, p => this.findPopupIn(p));
+    }
+    findPopupIn(p) {
+        return this.getOverlay().find('.mat-menu-panel');
+    }
+    getOverlay() {
+        return this.dom().closest('body').find('.cdk-overlay-container');
+    }
+    getBackdrop() {
+        return this.getOverlay().find('.cdk-overlay-backdrop');
+    }
+    openPopup() {
+        this.shouldNotBeOpen();
+        this.click();
+        return this.popup;
+    }
+    closePopup() {
+        this.shouldBeOpen();
+        this.getBackdrop().click();
+    }
+    shouldBeOpen() {
+        this.popup.shouldBeVisible();
+    }
+    shouldNotBeOpen() {
+        this.dom().closest('body').find('.mat-menu-panel').should("not.exist");
+    }
+}
+
+class AupMoreMenu extends AupAbstractPopupMenu {
+    static create(parent, selector) {
+        return new AupMoreMenu(parent, ElementLocator.findByCssSelector(selector !== null && selector !== void 0 ? selector : 'aup-more-menu'));
+    }
+}
+
 class AupNavigation extends PageElement {
     click(label) {
         return super.click(label);
@@ -241,140 +249,430 @@ class AupNavigation extends PageElement {
         this.face(label).shouldBeVisible();
     }
     shouldNotHaveLink(label) {
-        this.face(label).shouldNotBeVisible();
+        this.face(label).shouldNotExist();
+    }
+}
+
+class AupTableCell extends PageElement {
+    rowId() {
+        return this.dom().closest('tr').invoke('attr', 'aup-row-id');
+    }
+    row() {
+        const self = this;
+        return this.parent.createRow(parent => {
+            return self.rowId().then(rowId => parent.dom().find(AupAbstractTable.cssSelectorForTableRowById(rowId)));
+        });
+    }
+}
+
+class AupTableColumn extends PageElement {
+    constructor(table, columnId) {
+        super(table, AupAbstractTable.cssSelectorForColumnCellRendererById(columnId));
+        this.columnId = columnId;
+    }
+    cellContaining(content) {
+        const self = this;
+        return new AupTableCell(this.parent, parent => {
+            return parent.dom().contains(AupAbstractTable.cssSelectorForColumnCellRendererById(self.columnId), content);
+        });
+    }
+    rowContaining(content) {
+        return this.cellContaining(content).row();
     }
 }
 
-class AupTable extends PageElement {
-    constructor(parentElementAccessor, selector) {
-        super(parentElementAccessor, selector);
+class AupTableSelectionColumn extends AupTableColumn {
+    selectAll() {
     }
+}
+
+class AupAbstractTable extends PageElement {
     row(rowId) {
-        return new AupTable.Row(() => this.element(), `tr[aup-table-id=${rowId}]`);
+        return this.createRow(parent => {
+            return parent.dom().find(AupAbstractTable.cssSelectorForTableRowById(rowId));
+        });
+    }
+    rowNumber(rowNumber) {
+        return this.createRow(parent => {
+            return parent.dom().find(AupAbstractTable.cssSelectorForNthTableRow(rowNumber));
+        });
     }
     column(columnId) {
-        return new AupTable.Column(this, columnId);
+        return new AupTableColumn(this, columnId);
+    }
+    get selectionColumn() {
+        return new AupTableSelectionColumn(this, 'selection-column');
     }
 }
-(function (AupTable) {
-    class Row extends PageElement {
+__decorate([
+    Memoize(),
+    __metadata("design:type", AupTableSelectionColumn),
+    __metadata("design:paramtypes", [])
+], AupAbstractTable.prototype, "selectionColumn", null);
+(function (AupAbstractTable) {
+    function cssSelectorForTableRowById(rowId) {
+        return `tbody tr[aup-row-id=${rowId}]`;
+    }
+    AupAbstractTable.cssSelectorForTableRowById = cssSelectorForTableRowById;
+    function cssSelectorForNthTableRow(rowNumber) {
+        return `tbody tr:nth-child(${rowNumber})`;
+    }
+    AupAbstractTable.cssSelectorForNthTableRow = cssSelectorForNthTableRow;
+    function cssSelectorForColumnCellRendererById(columnOrId) {
+        const columnId = _.isString(columnOrId) ? columnOrId : columnOrId.columnId;
+        return `aup-table-cell-renderer[column-id=${columnId}]`;
+    }
+    AupAbstractTable.cssSelectorForColumnCellRendererById = cssSelectorForColumnCellRendererById;
+    function cssSelectorForCell(rowId, columnOrId) {
+        return `${cssSelectorForTableRowById(rowId)} ${cssSelectorForColumnCellRendererById(columnOrId)}`;
+    }
+    AupAbstractTable.cssSelectorForCell = cssSelectorForCell;
+})(AupAbstractTable || (AupAbstractTable = {}));
+
+/* tslint:disable:unified-signatures */
+class AupTableRow extends PageElement {
+    rowId() {
+        return this.dom()
+            .invoke('attr', 'aup-row-id');
+    }
+    shouldHaveRowId(rowId) {
+        this.rowId().should('eq', rowId);
+    }
+    cell(columnOrId) {
+        const self = this;
+        return new AupTableCell(this.parent, parent => {
+            return self.rowId()
+                .then(rowId => AupAbstractTable.cssSelectorForCell(rowId, columnOrId))
+                .then(selector => parent.dom().find(selector));
+        });
+    }
+    shouldBeSelected() {
+        this.dom().should('have.class', 'aup-row-selected');
+    }
+    shouldNotBeSelected() {
+        this.dom().should('not.have.class', 'aup-row-selected');
+    }
+}
+
+class AupTable extends AupAbstractTable {
+    createRow(locator) {
+        return new AupTableRow(this, locator);
+    }
+}
+
+class AupTreeTable extends AupAbstractTable {
+    get treeControlColumn() {
+        return new AupTreeTable.TreeControlColumn(this, 'tree-label');
+    }
+    createRow(locator) {
+        return new AupTreeTable.Row(this, locator);
     }
-    AupTable.Row = Row;
-    class Column {
-        constructor(table, columnId) {
-            this.table = table;
-            this.columnId = columnId;
+}
+__decorate([
+    Memoize(),
+    __metadata("design:type", AupTreeTable.TreeControlColumn),
+    __metadata("design:paramtypes", [])
+], AupTreeTable.prototype, "treeControlColumn", null);
+(function (AupTreeTable) {
+    class Row extends AupTableRow {
+        shouldBeExpanded() {
+            this.dom().should("not.have.class", "aup-node-collapsed");
         }
-        cell(content) {
-            const self = this;
-            return new Cell(this.table, {
-                findIn(parent) {
-                    return parent.contains(`aup-table-cell-renderer[column-id=${self.columnId}]`, content);
-                }
-            });
+        shouldBeCollapsed() {
+            this.dom().should("have.class", "aup-node-collapsed");
         }
     }
-    AupTable.Column = Column;
-    class Cell extends PageElement {
+    AupTreeTable.Row = Row;
+    class TreeControlColumn extends AupTableColumn {
     }
-    AupTable.Cell = Cell;
-})(AupTable || (AupTable = {}));
+    AupTreeTable.TreeControlColumn = TreeControlColumn;
+})(AupTreeTable || (AupTreeTable = {}));
 
-function ButtonMixin(Base) {
+function FormElementMixin(Base) {
     return class extends Base {
         constructor(...args) {
             super(...args);
         }
-        click() {
-            return this.element().click();
-        }
         shouldBeDisabled() {
             this.should("be.disabled");
-            // this.should("have.css", "color", "rgba(0,0,0,0.26)")
         }
     };
 }
 
-class Button extends ButtonMixin(PageElement) {
+class Button extends FormElementMixin(PageElement) {
     constructor(parentElementAccessor, buttonText) {
-        super(parentElementAccessor, {
-            findIn(parent) {
-                return parent.contains('button', buttonText);
-            },
-            shouldNotExist(parent) {
-                return parent.should('not.contain', buttonText);
+        super(parentElementAccessor, ElementLocator.findBySelectorAndTextContent('button', buttonText));
+    }
+}
+
+class MatCheckbox extends FormElementMixin(PageElement) {
+    constructor(parentElementAccessor, text) {
+        super(parentElementAccessor, ElementLocator.findBySelectorAndTextContent('mat-checkbox', text));
+    }
+    shouldBeChecked() {
+        this.hiddenCheckBoxElement().should('be.checked');
+    }
+    shouldNotBeChecked() {
+        this.hiddenCheckBoxElement().should('not.be.checked');
+    }
+    hiddenCheckBoxElement() {
+        return this.dom().find('input[type=checkbox]');
+    }
+    check() {
+        this.hiddenCheckBoxElement().then(el => {
+            if (!el.prop('checked')) {
+                this.click();
+                this.shouldBeChecked();
+            }
+        });
+    }
+    uncheck() {
+        this.hiddenCheckBoxElement().then(el => {
+            if (el.prop('checked')) {
+                this.click();
+                this.shouldNotBeChecked();
             }
         });
     }
 }
 
-var Section;
-(function (Section) {
-    function create(builder) {
-        const impl = new StandAloneSection();
-        return Mixin.createProxy(builder(impl), impl);
+class ComponentBuilder {
+    constructor(parentPageElement) {
+        this.parentPageElement = parentPageElement;
+    }
+    find(selector) {
+        return new PageElement(this.parentPageElement, selector);
+    }
+    section(selector, builder) {
+        return this.component(PageElement, selector, builder);
+    }
+    contains(text) {
+        return new PageElement(this.parentPageElement, ElementLocator.findByTextContent(text));
+    }
+    button(text) {
+        return new Button(this.parentPageElement, text);
+    }
+    matCheckbox(text) {
+        return new MatCheckbox(this.parentPageElement, text);
+    }
+    aupStringInput(selector) {
+        return new AupInput.HtmlInput(this.parentPageElement, selector !== null && selector !== void 0 ? selector : 'aup-string-input');
+    }
+    aupTextInput(selector) {
+        return new AupInput.TextAreaInput(this.parentPageElement, selector !== null && selector !== void 0 ? selector : 'aup-text-input');
+    }
+    aupPasswordInput(selector) {
+        return new AupInput.HtmlInput(this.parentPageElement, selector !== null && selector !== void 0 ? selector : 'aup-password-input');
+    }
+    aupNumberInput(selector) {
+        return new AupInput.HtmlInput(this.parentPageElement, selector !== null && selector !== void 0 ? selector : 'aup-number-input');
+    }
+    aupCommand(faceOrSelector) {
+        return new AupCommand(this.parentPageElement, faceOrSelector);
     }
-    Section.create = create;
-    function Mixin$1(Base) {
+    aupTabbedNavigation() {
+        return new AupNavigation(this.parentPageElement, 'aup-tabbed-place-navigation');
+    }
+    aupSideNavigation() {
+        return new AupNavigation(this.parentPageElement, 'aup-list-place-nav');
+    }
+    aupMoreMenu(selector) {
+        return AupMoreMenu.create(this.parentPageElement, selector);
+    }
+    aupTable(selectorOrBuilder, optionalBuilder) {
+        return this.component(AupTable, selectorOrBuilder, optionalBuilder);
+    }
+    aupTreeTable(selectorOrBuilder, optionalBuilder) {
+        return this.component(AupTreeTable, selectorOrBuilder, optionalBuilder);
+    }
+    aupEmptyState(selectorOrBuilder, optionalBuilder) {
+        return this.component(AupEmptyState, selectorOrBuilder, optionalBuilder);
+    }
+    component(klass, selectorOrBuilder, optionalBuilder) {
+        const selector = _.isString(selectorOrBuilder) ? selectorOrBuilder : undefined;
+        const builder = _.isFunction(selectorOrBuilder) ? selectorOrBuilder : optionalBuilder;
+        const element = new klass(this.parentPageElement, selector);
+        if (builder) {
+            // create the B&E type that the builder has access to
+            const decoratedElement = Mixin.createProxy(element, new ComponentBuilder(element));
+            // create final type that has the E & T type
+            return Mixin.createProxy(decoratedElement, builder(decoratedElement));
+        }
+        else {
+            return element;
+        }
+    }
+}
+(function (ComponentBuilder) {
+    function Mixin(Base) {
         return class extends Base {
-            section(selector, section) {
-                const impl = new NestedSection(this, selector);
-                return Mixin.createProxy(section(impl), impl);
-            }
-            find(selector) {
-                return new PageElement(() => this.element(), selector);
-            }
-            contains(text) {
-                return new PageElement(() => this.element(), {
-                    findIn: parent => parent.contains(text),
-                    shouldNotExist: (parent) => parent.should('not.contain', text)
-                });
-            }
-            button(text) {
-                return new Button(() => this.element(), text);
-            }
-            aupStringInput(selector) {
-                return new AupInput.HtmlInput(() => this.element(), selector !== null && selector !== void 0 ? selector : 'aup-string-input');
-            }
-            aupTextInput(selector) {
-                return new AupInput.TextAreaInput(() => this.element(), selector !== null && selector !== void 0 ? selector : 'aup-text-input');
-            }
-            aupPasswordInput(selector) {
-                return new AupInput.HtmlInput(() => this.element(), selector !== null && selector !== void 0 ? selector : 'aup-password-input');
-            }
-            aupNumberInput(selector) {
-                return new AupInput.HtmlInput(() => this.element(), selector !== null && selector !== void 0 ? selector : 'aup-number-input');
-            }
-            aupCommand(face) {
-                return new AupCommand(this, face);
-            }
-            aupTabbedNavigation() {
-                return new AupNavigation(this, 'aup-tabbed-place-navigation');
-            }
-            aupSideNavigation() {
-                return new AupNavigation(() => this.element(), 'aup-list-place-nav');
-            }
-            aupTable(selector) {
-                return new AupTable(() => this.element(), selector !== null && selector !== void 0 ? selector : 'aup-table');
-            }
-            aupEmptyState(selector) {
-                return new AupEmptyState(this, selector);
+            constructor(...args) {
+                super(...args);
+                this.builder = new ComponentBuilder(this);
             }
         };
     }
-    Section.Mixin = Mixin$1;
-    class NestedSection extends Mixin$1(PageElement) {
+    ComponentBuilder.Mixin = Mixin;
+})(ComponentBuilder || (ComponentBuilder = {}));
+
+class AupAbstractActivity extends ComponentBuilder.Mixin(PageElement) {
+    constructor(parent, selector) {
+        // @ts-ignore
+        super(parent, selector);
+        this.title = this.find('aup-activity-title');
+        this._confirmCommand = this.builder.aupCommand('[data-cy=confirm-command]');
+        this._cancelCommand = this.builder.aupCommand('[data-cy=cancel-command]');
+    }
+}
+
+class AupAlert extends AupAbstractActivity {
+    constructor(parent, selector) {
+        super(parent, selector);
+    }
+    get closeCommand() {
+        return this._confirmCommand;
+    }
+    clickClose() {
+        this.closeCommand.click();
+    }
+}
+
+function AupModalMixin(Base) {
+    return class extends Base {
+        constructor(...args) {
+            super(...args);
+        }
+        getDefaultElementLocator() {
+            return (parent) => {
+                return parent.dom().closest('body').find(this.getDefaultElementSelector());
+            };
+        }
+        clickBackdrop() {
+            this.dom()
+                .closest(`.cdk-overlay-container`)
+                .find(`.cdk-overlay-backdrop`).click(-50, -50, { force: true });
+        }
+    };
+}
+
+class AupAlertDialog extends AupModalMixin(AupAlert) {
+    constructor(parent, selector) {
+        super(parent, selector);
+    }
+}
+
+class AupConfirm extends AupAbstractActivity {
+    constructor(parent, selector) {
+        super(parent, selector);
+    }
+    get confirmCommand() {
+        return this._confirmCommand;
+    }
+    clickConfirm() {
+        this.confirmCommand.click();
+    }
+    get cancelCommand() {
+        return this._cancelCommand;
+    }
+    clickCancel() {
+        this.cancelCommand.click();
+    }
+}
+
+class AupConfirmDialog extends AupModalMixin(AupConfirm) {
+    constructor(parent, selector) {
+        super(parent, selector);
+    }
+}
+
+class AupActivity extends AupAbstractActivity {
+    constructor(parent, selector) {
+        super(parent, selector);
+    }
+    get confirmCommand() {
+        return this._confirmCommand;
+    }
+    get cancelCommand() {
+        return this._cancelCommand;
+    }
+}
+
+class AupModalActivity extends AupModalMixin(AupActivity) {
+}
+
+class PageBuilder extends ComponentBuilder {
+    aupModalActivity(selector, builder) {
+        return this.component(AupModalActivity, selector, builder);
+    }
+    aupModalAlert(builder) {
+        return this.component(AupAlertDialog, builder);
+    }
+    aupModelConfirm(builder) {
+        return this.component(AupConfirmDialog, builder);
+    }
+}
+
+let urlSerialiser = new DefaultUrlSerializer();
+class Path {
+    constructor(segments) {
+        this.segments = segments;
+    }
+    static extractVisitParameters(url) {
+        var _a, _b;
+        let result = {};
+        const urlTree = urlSerialiser.parse(url);
+        const urlSegments = (_b = (_a = urlTree.root.children.primary) === null || _a === void 0 ? void 0 : _a.segments) !== null && _b !== void 0 ? _b : [];
+        urlSegments === null || urlSegments === void 0 ? void 0 : urlSegments.forEach(s => {
+            result = Object.assign(Object.assign({}, result), s.parameters);
+        });
+        return result;
     }
-    class StandAloneSection extends Mixin$1(PageElement) {
+    toUrl(matrixParams) {
+        return this.segments.map(s => s.toUrlPart(matrixParams)).join('/');
+    }
+}
+(function (Path) {
+    function setUrlSerialiser(serialiser) {
+        urlSerialiser = serialiser;
+    }
+    Path.setUrlSerialiser = setUrlSerialiser;
+    class Segment {
+        constructor(path, params = {}) {
+            var _a;
+            this.path = path;
+            this.routeId = params === null || params === void 0 ? void 0 : params.routeId;
+            this.visitParams = (_a = params === null || params === void 0 ? void 0 : params.visitParams) !== null && _a !== void 0 ? _a : [];
+        }
+        toUrlPart(params) {
+            let path = this.path;
+            this.visitParams.forEach(p => {
+                const value = params[p];
+                if (value) {
+                    path = `${path};${p}=${value}`;
+                }
+            });
+            if (this.routeId && params[this.routeId]) {
+                path = path + '/' + params[this.routeId];
+            }
+            return path;
+        }
+    }
+    Path.Segment = Segment;
+    class Builder {
         constructor() {
-            super(undefined, undefined);
-            this.rootElementSelector = 'body';
+            this.segments = [];
         }
-        element() {
-            return cy.get(this.rootElementSelector);
+        segment(name, params) {
+            const builder = new Segment(name, params);
+            this.segments.push(builder);
+            return this;
+        }
+        getPath() {
+            return new Path(this.segments);
         }
     }
-})(Section || (Section = {}));
+    Path.Builder = Builder;
+})(Path || (Path = {}));
 
 class Page extends PageElement {
     constructor(path) {
@@ -382,7 +680,7 @@ class Page extends PageElement {
         this.path = path;
         this.rootElementSelector = 'body';
     }
-    element() {
+    dom() {
         return cy.get(this.rootElementSelector);
     }
     visit(visitParams, queryParams) {
@@ -392,7 +690,9 @@ class Page extends PageElement {
     tryAndVisit(params, queryParams) {
         const path = this.path.toUrl(params !== null && params !== void 0 ? params : {});
         const queryString = queryParams ? `?${new URLSearchParams(queryParams).toString()}` : '';
-        cy.visit(`/${path}${queryString}`);
+        const fullPath = `/${path}${queryString}`;
+        cy.log(`Visiting -> ${fullPath}`);
+        cy.visit(fullPath);
     }
     shouldHaveActivityIds(...ids) {
         cy.location('search').should('contain', `?aup-interactions=${ids.join('--')}`);
@@ -405,71 +705,73 @@ class Page extends PageElement {
     }
     shouldBeActive(withParameters) {
         // Note: cy.window() doesn't return a promise... it's a chainable.
-        cy["waitUntil"](() => {
+        cy['waitUntil'](() => {
             return cy.window().then(window => {
                 return window['aup.PlaceRouter'] && !window['aup.PlaceRouter'].isNavigating();
             });
         });
         if (withParameters) {
-            cy.location('pathname').then(path => {
-                const urlParams = Path.extractVisitParameters(path);
-                Object.keys(withParameters).forEach(param => {
-                    const expected = withParameters[param];
-                    // @ts-ignore
-                    expect(urlParams[param]).to.equal(expected);
-                });
-            });
+            this.shouldIncludeParameters(withParameters);
         }
     }
+    shouldIncludeParameters(parameters) {
+        cy.location('pathname').then(path => {
+            const urlParams = Path.extractVisitParameters(path);
+            Object.keys(parameters).forEach(param => {
+                const expected = parameters[param];
+                const actual = urlParams[param];
+                // cy.log(`${actual} - ${expected}`);
+                expect(urlParams[param]).to.equal(expected);
+            });
+        });
+    }
+    shouldNotHaveParameter(name) {
+        this.getUrlParameters().then(params => {
+            expect(params[name]).to.be.undefined;
+        });
+    }
+    getUrlParameters() {
+        return cy.location('pathname').then(path => Path.extractVisitParameters(path));
+    }
 }
 (function (Page) {
-    function create(pathOrPathBuilder, page) {
+    function create(pathOrPathBuilder, builder) {
         const pathBuilder = new Path.Builder();
         if (_.isString(pathOrPathBuilder)) {
-            pathOrPathBuilder.split("/").filter(p => !_.isEmpty(p)).forEach(p => pathBuilder.segment(p));
+            pathOrPathBuilder.split('/').filter(p => !_.isEmpty(p)).forEach(p => pathBuilder.segment(p));
         }
         else {
             pathOrPathBuilder(pathBuilder);
         }
-        const builder = new PageBuilder(pathBuilder.getPath());
-        return Mixin.createProxy(page(builder), builder);
+        const instance = new Page(pathBuilder.getPath());
+        const content = builder.call(instance, new PageBuilder(instance));
+        return Mixin.createProxy(content, instance);
     }
     Page.create = create;
-    class PageBuilder extends Section.Mixin(Page) {
-    }
-    Page.PageBuilder = PageBuilder;
 })(Page || (Page = {}));
 
 class AupCommandGroup extends PageElement {
 }
 
-class AupMoreMenu extends PageElement {
-    static create(parent) {
-        return new AupMoreMenu(parent, 'aup-more-menu');
+class AupToolBar extends PageElement {
+    static create(parent, face) {
+        // const findFace = AupCommandFace.createFinder(() => parent.element(), face)
+        // return new AupCommandGroup(() => findFace().closest('button'));
     }
 }
 
-class AupPopupMenu extends PageElement {
+class AupPopupMenu extends AupAbstractPopupMenu {
     constructor(parentElementAccessor, face) {
-        const accessor = AupCommandFace.createAccessor(face);
-        super(parentElementAccessor, {
-            findIn(parent) {
-                return accessor.findIn(parent).closest('button');
-            },
-            shouldNotExist(parent) {
-                accessor.shouldNotExist(parent);
-            }
-        });
+        const locator = AupCommandFace.createElementLocator(face);
+        super(parentElementAccessor, parent => locator(parent).closest('button'));
     }
     static create(parent, face) {
         return new AupPopupMenu(parent, face);
     }
 }
 
-class AupToolBar extends PageElement {
-    static create(parent, face) {
-        // const findFace = AupCommandFace.createFinder(() => parent.element(), face)
-        // return new AupCommandGroup(() => findFace().closest('button'));
+class AupTableSelectionCell extends AupTableCell {
+    selectAll() {
     }
 }
 
@@ -481,5 +783,5 @@ class AupToolBar extends PageElement {
  * Generated bundle index. Do not edit.
  */
 
-export { AupCommand, AupCommandFace, AupCommandGroup, AupEmptyState, AupInput, AupMoreMenu, AupNavigation, AupPopupMenu, AupTable, AupToolBar, Button, ButtonMixin, FaceAccessor, Page, PageElement, Path, Section };
+export { AupAbstractActivity, AupAbstractPopupMenu, AupAbstractTable, AupActivity, AupAlert, AupAlertDialog, AupCommand, AupCommandFace, AupCommandGroup, AupConfirm, AupConfirmDialog, AupEmptyState, AupInput, AupModalActivity, AupModalMixin, AupMoreMenu, AupNavigation, AupPopupMenu, AupPopupMenuPanel, AupTable, AupTableCell, AupTableColumn, AupTableRow, AupTableSelectionCell, AupTableSelectionColumn, AupToolBar, AupTreeTable, Button, ComponentBuilder, ElementLocator, FormElementMixin, MatCheckbox, Page, PageBuilder, PageElement, Path };
 //# sourceMappingURL=coolon-angular-ui-powerups-cypress.js.map