@sprucelabs/spruce-cli 18.4.0 → 19.1.0

package/node_modules/@sprucelabs/heartwood-view-controllers/build/tests/utilities/vcAssert.js

@@ -0,0 +1,1075 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeScopeFromVc = void 0;
+const schema_1 = require("@sprucelabs/schema");
+const test_utils_1 = require("@sprucelabs/test-utils");
+const card_schema_1 = __importDefault(require("./../../.spruce/schemas/heartwoodViewControllers/v2021_02_11/card.schema"));
+const controllerMap_1 = require("../../controllerMap");
+const render_utility_1 = __importDefault(require("../../utilities/render.utility"));
+const ActiveRecordCard_vc_1 = __importDefault(require("../../viewControllers/activeRecord/ActiveRecordCard.vc"));
+const sectionIdOrIdxToIdx_1 = __importDefault(require("../../viewControllers/card/sectionIdOrIdxToIdx"));
+const List_vc_1 = __importDefault(require("../../viewControllers/list/List.vc"));
+const SwipeCard_vc_1 = __importDefault(require("../../viewControllers/SwipeCard.vc"));
+const assertSupport_1 = require("./assertSupport");
+const attachTriggerRenderCounter_1 = require("./attachTriggerRenderCounter");
+const listAssert_1 = __importDefault(require("./listAssert"));
+const toolBeltAssert_1 = __importDefault(require("./toolBeltAssert"));
+const vcAssert = {
+    _setVcFactory(factory) {
+        //@ts-ignore
+        this.factory = factory;
+    },
+    attachTriggerRenderCounter(vc) {
+        //@ts-ignore
+        (0, attachTriggerRenderCounter_1.attachTriggerRenderCounter)(vc);
+    },
+    assertTriggerRenderCount(vc, expected) {
+        var _a;
+        //@ts-ignore
+        let actual = vc.__renderInvocationCount;
+        if (typeof actual === 'undefined') {
+            this.attachTriggerRenderCounter(vc);
+            actual = 0;
+        }
+        test_utils_1.assert.isEqual(actual, expected, `Expected triggerRender of '${
+        //@ts-ignore
+        (_a = vc.id) !== null && _a !== void 0 ? _a : 'view controller'}' to be invoked '${expected}' time${expected === 1 ? '' : 's'}, but it was actually invoked '${actual}' time${actual === 1 ? '' : 's'}.`);
+    },
+    async assertRendersConfirm(vc, action) {
+        let confirmVc = {
+            //@ts-ignore
+            id: 'confirm',
+            accept: async () => { },
+            options: {},
+            decline: async () => { },
+        };
+        let wasHit = false;
+        const confirmPromise = new Promise((confirmResolve) => {
+            //@ts-ignore
+            const originalConfirm = vc._originalConfirm;
+            //@ts-ignore
+            vc.confirm = async (options) => {
+                wasHit = true;
+                originalConfirm === null || originalConfirm === void 0 ? void 0 : originalConfirm();
+                //@ts-ignore
+                confirmResolve();
+                confirmVc.options = options;
+                return new Promise((resolve) => {
+                    confirmVc.accept = async () => {
+                        resolve(true);
+                        await actionPromise;
+                    };
+                    confirmVc.decline = async () => {
+                        resolve(false);
+                        await actionPromise;
+                    };
+                });
+            };
+        });
+        const actionPromise = action();
+        await (0, assertSupport_1.wait)(actionPromise, confirmPromise);
+        test_utils_1.assert.isTrue(wasHit, `this.confirm() was not invoked in your view controller within ${assertSupport_1.WAIT_TIMEOUT} milliseconds.`);
+        return confirmVc;
+    },
+    async assertDoesNotRenderConfirm(vc, action) {
+        try {
+            await this.assertRendersConfirm(vc, action);
+        }
+        catch (_a) {
+            return;
+        }
+        test_utils_1.assert.fail(`Your view controller rendered a confirm and it should not have!`);
+    },
+    async assertDoesNotRenderDialog(vc, action) {
+        try {
+            await this.assertRendersDialog(vc, action);
+        }
+        catch (_a) {
+            return;
+        }
+        test_utils_1.assert.fail(`Your view controller rendered a dialog and it should not have!`);
+    },
+    async assertRendersSuccessAlert(vc, action) {
+        await this.assertRendersAlert(vc, action, 'success');
+    },
+    async assertRendersAlert(vc, action, style = 'error') {
+        var _a, _b;
+        let wasAlertTriggered = false;
+        //@ts-ignore
+        let oldAlert = vc._originalAlert ? vc._originalAlert : vc.alert.bind(vc);
+        let alertOptions;
+        //@ts-ignore
+        vc.alert = (options) => {
+            wasAlertTriggered = true;
+            alertOptions = options;
+            return oldAlert(options);
+        };
+        let dlgVc;
+        try {
+            dlgVc = await this.assertRendersDialog(vc, action);
+        }
+        catch (err) {
+            test_utils_1.assert.fail(`Expected this.alert() to be called in your view '${(0, assertSupport_1.getVcName)(vc)}' within 5 seconds and it wasn't.${err.stack.includes('renderInDialog(')
+                ? ``
+                : ` I was interrupted by this error:\n\n${(_a = err.stack) !== null && _a !== void 0 ? _a : err.message}`}`);
+        }
+        test_utils_1.assert.isTrue(wasAlertTriggered, `Expected this.alert() to be called in '${(0, assertSupport_1.getVcName)(vc)}' within 5 seconds and it wasn't.`);
+        //@ts-ignore
+        dlgVc.alertOptions = alertOptions;
+        const passedStyle = (_b = alertOptions.style) !== null && _b !== void 0 ? _b : 'error';
+        test_utils_1.assert.isEqual(passedStyle, style, `I expected this.alert({ type: '${style}' }) to be called in ${(0, assertSupport_1.getVcName)(vc)}, but it wasn't!`);
+        return dlgVc;
+    },
+    async assertDoesNotRenderAlert(vc, action, style = 'error') {
+        var _a;
+        //@ts-ignore
+        let oldAlert = vc._originalAlert
+            ? //@ts-ignore
+                vc._originalAlert.bind(vc)
+            : //@ts-ignore
+                (_a = vc.alert) === null || _a === void 0 ? void 0 : _a.bind(vc);
+        let message = '';
+        //@ts-ignore
+        vc._originalAlert = (options) => {
+            message = options.message;
+            return oldAlert(options);
+        };
+        try {
+            await this.assertRendersAlert(vc, action, style);
+        }
+        catch (_b) {
+            return;
+        }
+        test_utils_1.assert.fail(`Didn't expect your controller to render an alert, but it did! It reads:\n\n${message}`);
+    },
+    async assertAsksForAVote(vc, action) {
+        let wasHit = false;
+        const voteVc = {
+            castVote: async () => { },
+        };
+        let votePromise = new Promise((resolve) => {
+            //@ts-ignores
+            vc.voteHandler = async () => {
+                wasHit = true;
+                resolve();
+                await new Promise((resolve) => {
+                    voteVc.castVote = async () => {
+                        await resolve();
+                        await new Promise((resolve) => setTimeout(resolve, 0));
+                    };
+                });
+            };
+        });
+        await (0, assertSupport_1.wait)(action(), votePromise);
+        test_utils_1.assert.isTrue(wasHit, "I totally expected you to `await this.askForAVote()`, but you didn't.");
+        return voteVc;
+    },
+    async assertRendersDialog(vc, action, dialogHandler) {
+        let run = () => { };
+        return new Promise((resolve, reject) => {
+            var _a;
+            try {
+                let wasHit = false;
+                let dialogVc;
+                let dialogPromise = new Promise((resolve) => {
+                    var _a, _b, _c;
+                    const renderInDialogHandler = (...args) => {
+                        test_utils_1.assert.isFalsy(
+                        //@ts-ignore
+                        vc._currentlyRenderingInDialog, `Holy dialogs Batman! You tried to render more than 1 dialog!`);
+                        //@ts-ignore
+                        vc._currentlyRenderingInDialog = true;
+                        dialogVc = oldRenderInDialog(...args);
+                        //@ts-ignore
+                        dialogVc.getParent = () => {
+                            //@ts-ignore
+                            return dialogVc === null || dialogVc === void 0 ? void 0 : dialogVc.getCardVc().getParent();
+                        };
+                        resolve(undefined);
+                        const oldHide = dialogVc.hide.bind(dialogVc);
+                        dialogVc.hide = async () => {
+                            await oldHide();
+                            await new Promise((r) => setTimeout(r, 0));
+                        };
+                        return dialogVc;
+                    };
+                    //@ts-ignore
+                    const oldRenderInDialog = 
+                    //@ts-ignore
+                    (_c = (_a = vc._originalRenderInDialog) !== null && _a !== void 0 ? _a : 
+                    //@ts-ignore
+                    (_b = vc.renderInDialog) === null || _b === void 0 ? void 0 : _b.bind(vc)) !== null && _c !== void 0 ? _c : function () { };
+                    //@ts-ignore
+                    vc._originalRenderInDialog = oldRenderInDialog;
+                    //@ts-ignore
+                    vc.renderInDialog = renderInDialogHandler;
+                });
+                let dialogHandlerPromise;
+                //@ts-ignore
+                const originalHandler = (_a = vc.renderInDialogHandler) === null || _a === void 0 ? void 0 : _a.bind(vc);
+                //@ts-ignore
+                vc.renderInDialogHandler = ({ controller }) => {
+                    wasHit = true;
+                    originalHandler === null || originalHandler === void 0 ? void 0 : originalHandler({ controller });
+                    //@ts-ignore
+                    setTimeout(async () => {
+                        var _a, _b;
+                        dialogHandlerPromise = (_b = (_a = dialogHandler === null || dialogHandler === void 0 ? void 0 : dialogHandler(controller)) === null || _a === void 0 ? void 0 : _a.catch) === null || _b === void 0 ? void 0 : _b.call(_a, (err) => {
+                            reject(err);
+                        });
+                    }, 0);
+                };
+                run = async () => {
+                    try {
+                        await (0, assertSupport_1.wait)(action(), dialogPromise);
+                        test_utils_1.assert.isTrue(wasHit, `this.renderInDialog() was not invoked in your view controller within ${assertSupport_1.WAIT_TIMEOUT} milliseconds.`);
+                        await dialogHandlerPromise;
+                        test_utils_1.assert.isTruthy(dialogVc);
+                        //@ts-ignore
+                        vc._currentlyRenderingInDialog = false;
+                        resolve(dialogVc);
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                };
+                void run();
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    },
+    assertCardRendersSection(vc, sectionIdOrIdx) {
+        checkForCardSection(vc, sectionIdOrIdx);
+    },
+    assertCardDoesNotRenderSection(vc, sectionIdOrIdx) {
+        try {
+            this.assertCardRendersSection(vc, sectionIdOrIdx);
+        }
+        catch (_a) {
+            return;
+        }
+        test_utils_1.assert.fail(`I found the section '${sectionIdOrIdx}' in your card and I should not have!`);
+    },
+    assertCardSectionRendersButton(vc, sectionIdOrIdx, buttonId) {
+        var _a;
+        const section = checkForCardSection(vc, sectionIdOrIdx);
+        if (buttonId) {
+            const match = (_a = section === null || section === void 0 ? void 0 : section.buttons) === null || _a === void 0 ? void 0 : _a.find((b) => b.id === buttonId);
+            test_utils_1.assert.isTruthy(match, `Could not find button '${buttonId}' in section '${sectionIdOrIdx}'`);
+        }
+        else {
+            test_utils_1.assert.isTruthy(section === null || section === void 0 ? void 0 : section.buttons, `Could not find button in section '${sectionIdOrIdx}'`);
+        }
+    },
+    /**
+     * @deprecated vcAssert.assertCardRendersList(...) -> listAssert.cardRendersList(...)
+     */
+    assertCardRendersList(vc, id) {
+        const model = render_utility_1.default.render(vc);
+        const lists = (0, assertSupport_1.pluckAllFromCard)(
+        //@ts-ignore
+        model.body ? model : { body: model }, 'list');
+        let foundList = false;
+        let foundById = false;
+        let match;
+        for (const list of lists) {
+            if (!match && (list === null || list === void 0 ? void 0 : list.controller) instanceof List_vc_1.default) {
+                foundList = true;
+                match = list;
+            }
+            if (id && (list === null || list === void 0 ? void 0 : list.id) === id) {
+                foundById = true;
+                match = list;
+                break;
+            }
+        }
+        test_utils_1.assert.isTrue(foundList, "Expected to find a list inside your CardViewController, but didn't find one!");
+        if (id) {
+            test_utils_1.assert.isTrue(foundById, `Found a list, but nothing with the id '${id}'!`);
+        }
+        return match === null || match === void 0 ? void 0 : match.controller;
+    },
+    assertCardDoesNotRenderList(vc, id) {
+        try {
+            this.assertCardRendersList(vc, id);
+        }
+        catch (_a) {
+            return;
+        }
+        test_utils_1.assert.fail(`Your view controller renders a list${id ? ` with the id '${id}'` : ''} and it shouldn't.`);
+    },
+    assertCardRendersButtonBar(cardVc) {
+        var _a, _b, _c;
+        (0, schema_1.assertOptions)({ cardVc }, ['cardVc']);
+        const model = render_utility_1.default.render(cardVc);
+        const match = (_b = (_a = model.body) === null || _a === void 0 ? void 0 : _a.sections) === null || _b === void 0 ? void 0 : _b.find((s) => !!s.buttonBar);
+        test_utils_1.assert.isTruthy(match, `Your card does not render a button bar.`);
+        return (_c = match.buttonBar) === null || _c === void 0 ? void 0 : _c.controller;
+    },
+    assertDialogWasClosed(vc) {
+        test_utils_1.assert.isFalse(vc.getIsVisible(), 'Dialog was not closed!');
+    },
+    assertRendersValidCard(vc) {
+        var _a;
+        const model = render_utility_1.default.render(vc);
+        //@ts-ignore TODO make shouldAllowEditing part of formBuilderSchema
+        delete model.shouldAllowEditing;
+        (0, schema_1.validateSchemaValues)(card_schema_1.default, model);
+        if ((_a = model.footer) === null || _a === void 0 ? void 0 : _a.buttons) {
+            this.assertLastButtonInCardFooterIsPrimaryIfThereAreAnyButtons(vc);
+        }
+    },
+    assertLastButtonInCardFooterIsPrimaryIfThereAreAnyButtons(vc) {
+        var _a, _b, _c, _d;
+        const model = render_utility_1.default.render(vc);
+        const footer = (_a = model.footer) !== null && _a !== void 0 ? _a : {};
+        const primaryIdx = (_b = footer.buttons) === null || _b === void 0 ? void 0 : _b.findIndex((b) => b.type === 'primary');
+        if (footer.buttons &&
+            typeof primaryIdx === 'number' &&
+            primaryIdx > -1 &&
+            ((_d = (_c = footer.buttons) === null || _c === void 0 ? void 0 : _c[footer.buttons.length - 1]) === null || _d === void 0 ? void 0 : _d.type) !== 'primary') {
+            test_utils_1.assert.fail('Your primary button has to be last in your footer.');
+        }
+    },
+    assertCardRendersHeader(cardVc) {
+        const model = render_utility_1.default.render(cardVc);
+        test_utils_1.assert.isObject(model.header, `Your card did not render a header!`);
+    },
+    assertCardRendersFooter(cardVc) {
+        const model = render_utility_1.default.render(cardVc);
+        test_utils_1.assert.isObject(model.footer, `Your card did not render a footer!`);
+    },
+    assertButtonBarRendersButton(buttonBarVc, buttonId) {
+        (0, schema_1.assertOptions)({ buttonBarVc, buttonId }, ['buttonBarVc', 'buttonId']);
+        const model = render_utility_1.default.render(buttonBarVc);
+        const match = model.buttons.find((b) => b.id === buttonId);
+        test_utils_1.assert.isTruthy(match, `Your button bar doesn't have a button with the id '${buttonId}'`);
+    },
+    /**
+     * @deprecated vcAssert.assertListRendersRows(...) -> listAssert.listRendersRows(...)
+     */
+    assertListRendersRows(listVc, expectedRows) {
+        return listAssert_1.default.listRendersRows(listVc, expectedRows);
+    },
+    /**
+     * @deprecated vcAssert.assertListRendersRow(...) -> listAssert.listRendersRow(...)
+     */
+    assertListRendersRow(listVc, row) {
+        return listAssert_1.default.listRendersRow(listVc, row);
+    },
+    /**
+     * @deprecated vcAssert.assertRowRendersCheckBox(...) -> listAssert.rowRendersCheckBox(...)
+     */
+    assertRowRendersCheckBox(listVc, row, name) {
+        return listAssert_1.default.rowRendersCheckBox(listVc, row, name);
+    },
+    /**
+     * @deprecated vcAssert.assertRowRendersCalendar(...) -> listAssert.rowRendersCalendar(...)
+     */
+    assertRowRendersCalendar(listVc, row) {
+        return listAssert_1.default.rowRendersCalendar(listVc, row);
+    },
+    /**
+     * @deprecated vcAssert.assertRowRendersButtonBar(...) -> listAssert.rowRendersButtonBar(...)
+     */
+    assertRowRendersButtonBar(listVc, row) {
+        return listAssert_1.default.rowRendersButtonBar(listVc, row);
+    },
+    /**
+     * @deprecated vcAssert.assertRowRendersCell(...) -> listAssert.rowRendersCell(...)
+     */
+    assertRowRendersCell(listVc, row, cell) {
+        return listAssert_1.default.rowRendersCell(listVc, row, cell);
+    },
+    /**
+     * @deprecated vcAssert.assertRowDoesNotRenderCell(...) -> listAssert.rowDoesNotRenderCell(...)
+     */
+    assertRowDoesNotRenderCell(listVc, row, cell) {
+        return listAssert_1.default.rowDoesNotRenderCell(listVc, row, cell);
+    },
+    /**
+     * @deprecated vcAssert.assertRowRendersButton(...) -> listAssert.rowRendersButton(...)
+     */
+    assertRowRendersButton(listVc, row, buttonId) {
+        return listAssert_1.default.rowRendersButton(listVc, row, buttonId);
+    },
+    /**
+     * @deprecated vcAssert.assertRowDoesNotRenderButton(...) -> listAssert.rowDoesNotRenderButton(...)
+     */
+    assertRowDoesNotRenderButton(listVc, row, buttonId) {
+        return listAssert_1.default.rowDoesNotRenderButton(listVc, row, buttonId);
+    },
+    /**
+     * @deprecated vcAssert.assertListDoesNotRenderRow(...) -> listAssert.listDoesNotRenderRow(...)
+     */
+    assertListDoesNotRenderRow(listVc, row) {
+        return listAssert_1.default.listDoesNotRenderRow(listVc, row);
+    },
+    assertSkillViewRendersSwipeCard(vc) {
+        var _a;
+        (0, schema_1.assertOptions)({ vc }, ['vc']);
+        const model = render_utility_1.default.render(vc);
+        for (const layout of model.layouts) {
+            for (const card of (_a = layout.cards) !== null && _a !== void 0 ? _a : []) {
+                if (card.controller instanceof SwipeCard_vc_1.default) {
+                    return card.controller;
+                }
+            }
+        }
+        test_utils_1.assert.fail(`I could not find a swipe view in '${(0, assertSupport_1.getVcName)(vc)}'!`);
+        return {};
+    },
+    assertIsSwipeCard(vc) {
+        const { controller } = render_utility_1.default.render(vc);
+        test_utils_1.assert.isTrue(controller instanceof SwipeCard_vc_1.default, `I expected a swipe card view controller but got '${(0, assertSupport_1.getVcName)(vc)}'! Make your render something like 'return this.swipeVc.render()'`);
+    },
+    assertSkillViewRendersCard(vc, id) {
+        return this.assertSkillViewRendersCards(vc, id ? [id] : undefined)[0];
+    },
+    assertSkillViewDoesNotRenderCards(vc, expected) {
+        try {
+            this.assertSkillViewRendersCards(vc, expected);
+        }
+        catch (_a) {
+            return;
+        }
+        test_utils_1.assert.fail(`I didn't expect to find cards`);
+    },
+    assertSkillViewDoesNotRenderCard(vc, id) {
+        try {
+            this.assertSkillViewRendersCard(vc, id);
+        }
+        catch (_a) {
+            return;
+        }
+        test_utils_1.assert.fail(`I didn't expect to find a card with the id ${id}`);
+    },
+    assertSkillViewRendersCards(vc, expected) {
+        var _a, _b, _c;
+        const model = render_utility_1.default.render(vc);
+        const cards = [];
+        let matches = [];
+        for (const layout of (_a = model === null || model === void 0 ? void 0 : model.layouts) !== null && _a !== void 0 ? _a : []) {
+            for (const card of (_b = layout.cards) !== null && _b !== void 0 ? _b : []) {
+                if (card) {
+                    //@ts-ignore
+                    cards.push((_c = card.controller) !== null && _c !== void 0 ? _c : this.factory.Controller('card', card));
+                }
+            }
+        }
+        if (Array.isArray(expected)) {
+            for (const id of expected) {
+                const match = cards.find((c) => render_utility_1.default.render(c).id === id);
+                if (!match) {
+                    test_utils_1.assert.fail(`I could not find a card with the id of ${id}!`);
+                }
+                else {
+                    matches.push(match);
+                }
+            }
+        }
+        else if (typeof expected === 'number' && cards.length !== expected) {
+            test_utils_1.assert.fail(`Expected your skill view to render ${expected} card${expected === 1 ? '' : 's'}, but it got ${cards.length}.`);
+        }
+        else if (typeof expected === 'undefined' && cards.length === 0) {
+            test_utils_1.assert.fail('Expected your skill view to render a card, but it did not!');
+        }
+        else {
+            matches = cards;
+        }
+        return matches;
+    },
+    assertCardIsBusy(vc) {
+        var _a, _b;
+        const model = render_utility_1.default.render(vc);
+        if (!((_a = model.body) === null || _a === void 0 ? void 0 : _a.isBusy)) {
+            test_utils_1.assert.fail(`Expected your card '${(_b = model.id) !== null && _b !== void 0 ? _b : (0, assertSupport_1.getVcName)(vc)}' to be busy. Try 'this.setIsBusy(true)' or setting { body: { isBusy: true } }`);
+        }
+    },
+    assertCardIsNotBusy(vc) {
+        var _a, _b;
+        const model = render_utility_1.default.render(vc);
+        if ((_a = model.body) === null || _a === void 0 ? void 0 : _a.isBusy) {
+            test_utils_1.assert.fail(`Expected your card '${(_b = model.id) !== null && _b !== void 0 ? _b : (0, assertSupport_1.getVcName)(vc)}' not to be busy, but it was. Try 'this.setIsBusy(false)'.`);
+        }
+    },
+    /**
+     * @deprecated vcAssert.assertRowDoesNotRenderContent(...) -> listAssert.rowDoesNotRenderContent(...)
+     */
+    assertRowDoesNotRenderContent(vc, row, content) {
+        return listAssert_1.default.rowDoesNotRenderContent(vc, row, content);
+    },
+    /**
+     * @deprecated vcAssert.assertRowRendersContent(...) -> listAssert.rowRendersContent(...)
+     */
+    assertRowRendersContent(vc, row, content) {
+        return listAssert_1.default.rowRendersContent(vc, row, content);
+    },
+    assertSkillViewDoesNotRenderViewController(vc, VcClass) {
+        try {
+            this.assertSkillViewRendersViewController(vc, VcClass);
+        }
+        catch (_a) {
+            return;
+        }
+        //@ts-ignore
+        test_utils_1.assert.fail(`Expected not to find a ${VcClass.name} inside ${vc.id}!`);
+    },
+    assertSkillViewRendersViewController(vc, VcClass) {
+        var _a, _b, _c, _d;
+        const model = render_utility_1.default.render(vc);
+        const fieldsToCheck = Object.keys(controllerMap_1.CORE_CONTROLLER_MAP);
+        for (const layout of (_a = model.layouts) !== null && _a !== void 0 ? _a : []) {
+            for (const card of (_b = layout.cards) !== null && _b !== void 0 ? _b : []) {
+                const vc = findControllerInModel(VcClass, card);
+                if (vc) {
+                    return vc;
+                }
+                for (const section of (_d = (_c = card.body) === null || _c === void 0 ? void 0 : _c.sections) !== null && _d !== void 0 ? _d : []) {
+                    for (const f of fieldsToCheck) {
+                        //@ts-ignore
+                        const m = section[f];
+                        const vc = findControllerInModel(VcClass, m);
+                        if (vc) {
+                            return vc;
+                        }
+                    }
+                }
+            }
+        }
+        test_utils_1.assert.fail(`Expected a ${(0, assertSupport_1.getVcName)(vc)} to be rendered in your skill view, but it wasn't!`);
+    },
+    assertRowRendersButtonWithIcon(vc, icon) {
+        var _a, _b;
+        const model = render_utility_1.default.render(vc);
+        for (const cell of (_a = model === null || model === void 0 ? void 0 : model.cells) !== null && _a !== void 0 ? _a : []) {
+            if (((_b = cell.button) === null || _b === void 0 ? void 0 : _b.lineIcon) === icon) {
+                return;
+            }
+        }
+        test_utils_1.assert.fail(`Could not find button with 'lineIcon='${icon}'' in row!`);
+    },
+    assertFooterRendersButtonWithType(vc, type) {
+        var _a;
+        const model = render_utility_1.default.render(vc);
+        const buttons = (_a = model.footer) === null || _a === void 0 ? void 0 : _a.buttons;
+        if (!buttons ||
+            buttons.length === 0 ||
+            (type && !buttons.find((b) => b.type === type))) {
+            test_utils_1.assert.fail(`Your footer is supposed to render a${type ? ` ${type}` : ''} button but it doesn't!`);
+        }
+    },
+    assertCardDoesNotRenderButtons(vc, ids) {
+        try {
+            this.assertCardRendersButtons(vc, ids);
+        }
+        catch (_a) {
+            return;
+        }
+        const { found } = checkForButtons(vc, ids);
+        test_utils_1.assert.fail(`I did not expect your card to render buttons:\n\n${found.join(', ')}`);
+    },
+    assertCardDoesNotRenderButton(vc, id) {
+        try {
+            this.assertCardRendersButton(vc, id);
+        }
+        catch (_a) {
+            return;
+        }
+        test_utils_1.assert.fail(`I did not expect your card to render a button with the id '${id}', but it did!`);
+    },
+    assertCardRendersButtons(vc, ids) {
+        const { missing, foundButtons } = checkForButtons(vc, ids);
+        if (missing.length > 0) {
+            test_utils_1.assert.fail(`Your card '${(0, assertSupport_1.getVcName)(vc)}' is missing buttons with the following ids: ${missing.join(', ')}`);
+        }
+        return foundButtons.map((button) => ({
+            render() {
+                return button;
+            },
+            triggerRender() { },
+        }));
+    },
+    assertCardRendersButton(vc, id) {
+        return this.assertCardRendersButtons(vc, [id])[0];
+    },
+    assertCardRendersCriticalError(vc) {
+        const model = render_utility_1.default.render(vc);
+        test_utils_1.assert.isTruthy(model.criticalError, `I expected a critical error on your card, but didn'nt find one. Try 'this.cardVc.setCriticalError(...)'`);
+        return model.criticalError;
+    },
+    assertCardDoesNotRenderCriticalError(vc) {
+        const model = render_utility_1.default.render(vc);
+        test_utils_1.assert.isFalsy(model.criticalError, 'Your card was not supposed to render a critical error!');
+    },
+    /**
+     * @deprecated vcAssert.assertActionFocusesTool -> toolBeltAssert.actionFocusesTool
+     */
+    async assertActionFocusesTool(svcOrToolBelt, toolId, action) {
+        return toolBeltAssert_1.default.actionFocusesTool(svcOrToolBelt, toolId, action);
+    },
+    /**
+     * @deprecated vcAssert.assertActionOpensToolBelt -> toolBeltAssert.actionOpensToolBelt
+     */
+    async assertActionOpensToolBelt(svcOrToolBelt, action, options) {
+        return toolBeltAssert_1.default.actionOpensToolBelt(svcOrToolBelt, action, options);
+    },
+    /**
+     * @deprecated vcAssert.assertActionDoesNotOpenToolBelt -> toolBeltAssert.ActionDoesNotOpenToolBelt
+     */
+    async assertActionDoesNotOpenToolBelt(svcOrToolBelt, action) {
+        return toolBeltAssert_1.default.actionDoesNotOpenToolBelt(svcOrToolBelt, action);
+    },
+    /**
+     * @deprecated vcAssert.assertActionClosesToolBelt -> toolBeltAssert.actionClosesToolBelt
+     */
+    async assertActionClosesToolBelt(svcOrToolBelt, action) {
+        return toolBeltAssert_1.default.actionClosesToolBelt(svcOrToolBelt, action);
+    },
+    /**
+     * @deprecated vcAssert.assertActionDoesNotCloseToolBelt -> toolBeltAssert.actionDoesNotCloseToolBelt
+     */
+    async assertActionDoesNotCloseToolBelt(svcOrToolBelt, action) {
+        return toolBeltAssert_1.default.actionDoesNotCloseToolBelt(svcOrToolBelt, action);
+    },
+    /**
+     * @deprecated vcAssert.assertRendersToolBelt -> toolBeltAssert.rendersToolBelt
+     */
+    assertRendersToolBelt(svcOrToolBelt, assertHasAtLeast1Tool = true) {
+        return toolBeltAssert_1.default.rendersToolBelt(svcOrToolBelt, assertHasAtLeast1Tool);
+    },
+    /**
+     * @deprecated vcAssert.assertToolBeltDoesNotRenderStickyTools -> toolBeltAssert.toolBeltDoesNotRenderStickyTools
+     */
+    assertToolBeltDoesNotRenderStickyTools(svcOrToolBelt) {
+        return toolBeltAssert_1.default.toolBeltDoesNotRenderStickyTools(svcOrToolBelt);
+    },
+    /**
+     * @deprecated vcAssert.assertToolInstanceOf -> toolBeltAssert.toolInstanceOf
+     */
+    assertToolInstanceOf(svcOrToolBelt, toolId, Class) {
+        return toolBeltAssert_1.default.toolInstanceOf(svcOrToolBelt, toolId, Class);
+    },
+    /**
+     * @deprecated vcAssert.assertToolBeltDoesNotRenderTool -> toolBeltAssert.toolBeltDoesNotRenderTool
+     */
+    assertToolBeltDoesNotRenderTool(svc, toolId) {
+        return toolBeltAssert_1.default.toolBeltDoesNotRenderTool(svc, toolId);
+    },
+    /**
+     * @deprecated vcAssert.assertToolBeltStickyToolInstanceOf -> toolBeltAssert.toolBeltStickyToolInstanceOf
+     */
+    assertToolBeltStickyToolInstanceOf(options) {
+        return toolBeltAssert_1.default.toolBeltStickyToolInstanceOf(options);
+    },
+    /**
+     * @deprecated vcAssert.assertToolBeltRendersTool -> toolBeltAssert.toolBeltRendersTool
+     */
+    assertToolBeltRendersTool(svcOrToolBelt, toolId) {
+        return toolBeltAssert_1.default.toolBeltRendersTool(svcOrToolBelt, toolId);
+    },
+    /**
+     * @deprecated vcAssert.assertDoesNotRenderToolBelt -> toolBeltAssert.doesNotRenderToolBelt
+     */
+    assertDoesNotRenderToolBelt(svc) {
+        return toolBeltAssert_1.default.doesNotRenderToolBelt(svc);
+    },
+    assertSkillViewRendersCalendar(svc) {
+        var _a, _b;
+        const model = render_utility_1.default.render(svc);
+        for (const layout of (_a = model.layouts) !== null && _a !== void 0 ? _a : []) {
+            for (const card of (_b = layout === null || layout === void 0 ? void 0 : layout.cards) !== null && _b !== void 0 ? _b : []) {
+                const calendar = (0, assertSupport_1.pluckFirstFromCard)(card !== null && card !== void 0 ? card : {}, 'calendar');
+                if (calendar) {
+                    return calendar.controller;
+                }
+            }
+        }
+        test_utils_1.assert.fail('Your skill view does not render a calendar!');
+        return {};
+    },
+    assertCardRendersCalendar(vc) {
+        const model = render_utility_1.default.render(vc);
+        const calendar = (0, assertSupport_1.pluckFirstFromCard)(model, 'calendar');
+        if (calendar) {
+            return calendar.controller;
+        }
+        test_utils_1.assert.fail(`Your card '${(0, assertSupport_1.getVcName)(vc)}' does not render a calendar!`);
+        return {};
+    },
+    assertCardDoesNotRenderCalendar(vc) {
+        try {
+            this.assertCardRendersCalendar(vc);
+        }
+        catch (_a) {
+            return;
+        }
+        test_utils_1.assert.fail(`Your card rendered a calendar and should not.`);
+    },
+    /**
+     * @deprecated - use assertSkillViewRendersCalendar
+     */
+    assertRendersCalendar(svc) {
+        return this.assertSkillViewRendersCalendar(svc);
+    },
+    assertSkillViewDoesNotRenderCalendar(svc) {
+        try {
+            this.assertSkillViewRendersCalendar(svc);
+        }
+        catch (_a) {
+            return;
+        }
+        test_utils_1.assert.fail('Your skill view should not be rendering a calendar right now!');
+    },
+    /**
+     * @deprecated - use assertSkillViewDoesNotRenderCalendar
+     */
+    assertDoesNotRenderCalendar(svc) {
+        return this.assertSkillViewDoesNotRenderCalendar(svc);
+    },
+    assertCardRendersTalkingSprucebot(vc, id) {
+        const model = render_utility_1.default.render(vc);
+        const sprucebots = (0, assertSupport_1.pluckAllFromCard)(model, 'talkingSprucebot');
+        const sprucebot = sprucebots.find((sb) => (sb === null || sb === void 0 ? void 0 : sb.id) === id);
+        if (!sprucebot) {
+            test_utils_1.assert.fail(id
+                ? `I could not find a talking Sprucebot with the id '${id}' in your card!`
+                : 'Your card does not render a talking sprucebot!');
+        }
+        //@ts-ignore
+        return sprucebot.controller;
+    },
+    assertCardDoesNotRenderTalkingSprucebot(vc, id) {
+        try {
+            this.assertCardRendersTalkingSprucebot(vc, id);
+        }
+        catch (_a) {
+            return;
+        }
+        test_utils_1.assert.fail(`Your card wasn't supposed to render a talking sprucebot${id ? ` with the id of ${id}` : ''}, but it is!`);
+    },
+    assertIsFullScreen(vc) {
+        const model = render_utility_1.default.render(vc);
+        test_utils_1.assert.isTrue(model.isFullScreen, 'Your skill view is not being rendered full screen. Try setting `isFullScreen:true` in your view model.');
+    },
+    assertIsNotFullScreen(vc) {
+        try {
+            this.assertIsFullScreen(vc);
+        }
+        catch (_a) {
+            return;
+        }
+        test_utils_1.assert.fail('Your skill view is being rendered full screen. Try setting `isFullScreen:false` in your view model.');
+    },
+    async assertLoginIsRequired(vc) {
+        var _a;
+        const isRequired = await ((_a = vc.getIsLoginRequired) === null || _a === void 0 ? void 0 : _a.call(vc));
+        test_utils_1.assert.isTrue(isRequired, 
+        //@ts-ignore
+        `Your skill view ${(0, assertSupport_1.getVcName)(vc)} does not require login and it should! Try implementing 'public async getIsLoginRequired() { return true }' in your SkillViewController.`);
+    },
+    async assertLoginIsNotRequired(vc) {
+        try {
+            await this.assertLoginIsRequired(vc);
+        }
+        catch (_a) {
+            return;
+        }
+        test_utils_1.assert.fail(`Your skill view does not require login and it should! Make sure 'getIsLoginRequired' returns false in your SkillViewController.`);
+    },
+    async assertActionDoesNotRedirect(options) {
+        try {
+            await this.assertActionRedirects(options);
+        }
+        catch (_a) {
+            return;
+        }
+        test_utils_1.assert.fail(`You redirected and should not have!`);
+    },
+    async assertActionRedirects(options) {
+        var _a;
+        const { router, action, destination } = (0, schema_1.assertOptions)(options, [
+            'action',
+            'router',
+        ]);
+        //@ts-ignore
+        const oldRedirect = (_a = router._originalRedirect) !== null && _a !== void 0 ? _a : router.redirect.bind(router);
+        let wasHit = false;
+        let failMessage;
+        let results;
+        const redirectPromise = new Promise((resolve) => {
+            //@ts-ignore
+            router.redirect = async (id, args) => {
+                try {
+                    wasHit = true;
+                    if ((destination === null || destination === void 0 ? void 0 : destination.id) && destination.id !== id) {
+                        test_utils_1.assert.fail(`I expected to be redirected to '${destination.id}' but I was sent to '${id}'.`);
+                        return;
+                    }
+                    if (destination === null || destination === void 0 ? void 0 : destination.args) {
+                        test_utils_1.assert.isEqualDeep(args, destination.args, `The args you passed to your redirect are not what I expected!`);
+                    }
+                    //@ts-ignore
+                    results = oldRedirect(id, args);
+                    await results;
+                }
+                catch (err) {
+                    failMessage = err;
+                }
+                resolve();
+            };
+        });
+        await (0, assertSupport_1.wait)(action());
+        test_utils_1.assert.isTrue(wasHit, `I expected to be redirected, but was not!`);
+        await redirectPromise;
+        if (failMessage) {
+            throw failMessage;
+        }
+        return results;
+    },
+    /**
+     * @deprecated vcAssert.assertRowRendersToggle(...) -> listAssert.rowRendersToggle(...)
+     */
+    assertRowRendersToggle(listVc, row, toggleName) {
+        return listAssert_1.default.rowRendersToggle(listVc, row, toggleName);
+    },
+    /**
+     * @deprecated vcAssert.assertRowIsSelected(...) -> listAssert.rowIsSelected(...)
+     */
+    assertRowIsSelected(listVc, row) {
+        return listAssert_1.default.rowIsSelected(listVc, row);
+    },
+    /**
+     * @deprecated vcAssert.assertRowIsNotSelected(...) -> listAssert.rowIsNotSelected(...)
+     */
+    assertRowIsNotSelected(listVc, row) {
+        return listAssert_1.default.rowIsNotSelected(listVc, row);
+    },
+    /**
+     * @deprecated vcAssert.assertRowsAreSelected(...) -> listAssert.rowsAreSelected(...)
+     */
+    assertRowsAreSelected(listVc, rows) {
+        return listAssert_1.default.rowsAreSelected(listVc, rows);
+    },
+    /**
+     * @deprecated vcAssert.assertRowIsEnabled(...) -> listAssert.rowIsEnabled(...)
+     */
+    assertRowIsEnabled(listVc, row) {
+        return listAssert_1.default.rowIsEnabled(listVc, row);
+    },
+    /**
+     * @deprecated vcAssert.assertRowIsDisabled(...) -> listAssert.rowIsDisabled(...)
+     */
+    assertRowIsDisabled(listVc, row) {
+        return listAssert_1.default.rowIsDisabled(listVc, row);
+    },
+    /**
+     * @deprecated vcAssert.assertRowDoesNotRenderToggle(...) -> listAssert.rowDoesNotRenderToggle(...)
+     */
+    assertRowDoesNotRenderToggle(listVc, row, toggleName) {
+        return listAssert_1.default.rowDoesNotRenderToggle(listVc, row, toggleName);
+    },
+    /**
+     * @deprecated vcAssert.assertRowRendersSelect(...) -> listAssert.rowRendersSelect(...)
+     */
+    assertRowRendersSelect(listVc, row, name) {
+        return listAssert_1.default.rowRendersSelect(listVc, row, name);
+    },
+    /**
+     * @deprecated vcAssert.assertRowRendersRatings(...) -> listAssert.rowRendersRatings(...)
+     */
+    assertRowRendersRatings(listVc, row) {
+        return listAssert_1.default.rowRendersRatings(listVc, row);
+    },
+    assertSkillViewRendersActiveRecordCard(svc, id) {
+        const cardVc = this.assertSkillViewRendersCard(svc, id);
+        test_utils_1.assert.isTruthy(
+        //@ts-ignore
+        cardVc.__isActiveRecord, `I expected to find an active record card with the id of ${id}, but I didn't!`);
+        //@ts-ignore
+        return cardVc.__activeRecordParent;
+    },
+    assertIsActiveRecordCard(vc) {
+        var _a, _b;
+        const rendered = render_utility_1.default.render(vc);
+        test_utils_1.assert.isTruthy(vc instanceof ActiveRecordCard_vc_1.default ||
+            //@ts-ignore
+            vc.__activeRecordParent ||
+            //@ts-ignore
+            ((_b = (_a = rendered === null || rendered === void 0 ? void 0 : rendered.controller) === null || _a === void 0 ? void 0 : _a.getParent) === null || _b === void 0 ? void 0 : _b.call(_a)) instanceof
+                ActiveRecordCard_vc_1.default, `The card you sent was not an active record card!`);
+    },
+    assertControllerInstanceOf(vc, Class) {
+        var _a, _b, _c;
+        test_utils_1.assert.isTruthy(vc, 'Expected a vc but received null!');
+        const match = (0, assertSupport_1.isVcInstanceOf)(vc, Class);
+        test_utils_1.assert.isTruthy(match, `Expected your ${(_c = (_b = (_a = Object.getPrototypeOf(vc)) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : 'view controller'} to be an instance of ${Class.name}, but it wasn't!`);
+        return match;
+    },
+    assertRendersAsInstanceOf(vc, Class) {
+        var _a, _b, _c;
+        const model = render_utility_1.default.render(vc);
+        test_utils_1.assert.isTruthy(model.controller, `Your view controller does not return a controller. Make sure you return 'controller:this' from render() or that you're rending a built in view with 'render() { return this.cardVc.render() }'.`);
+        try {
+            return this.assertControllerInstanceOf(model.controller, Class);
+        }
+        catch (_d) {
+            test_utils_1.assert.fail(`Expected your ${(_c = (_b = (_a = Object.getPrototypeOf(vc)) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : 'view controller'} to render a controller that is an instance of ${Class.name}, but it didn't!`);
+        }
+        return {};
+    },
+    assertCardRendersStats(vc) {
+        const model = render_utility_1.default.render(vc);
+        const match = (0, assertSupport_1.pluckFirstFromCard)(model, 'stats');
+        test_utils_1.assert.isTruthy(match, `Your card did not render stats and I expected it to!`);
+        return match.controller;
+    },
+    assertStatsRendersValue(vc, idx, value) {
+        var _a;
+        const model = render_utility_1.default.render(vc);
+        const expected = (_a = model.stats[idx]) === null || _a === void 0 ? void 0 : _a.value;
+        test_utils_1.assert.isEqual(expected, value, `Expected stats to render '${value}' at index '${idx}', but found '${expected !== null && expected !== void 0 ? expected : 'nothing'}'.`);
+    },
+    async assertRendersAlertThenRedirects(options) {
+        await this.assertActionRedirects(Object.assign(Object.assign({}, options), { action: async () => {
+                const alertVc = await this.assertRendersAlert(options.vc, options.action);
+                await alertVc.hide();
+            } }));
+    },
+    patchAlertToThrow(vc) {
+        //@ts-ignore
+        if (!vc._originalAlert) {
+            //@ts-ignore
+            vc._originalAlert = vc.alert.bind(vc);
+        }
+        //@ts-ignore
+        vc.alert = async (options) => {
+            if (!options.style || options.style === 'error') {
+                test_utils_1.assert.fail(`Skill view '${(0, assertSupport_1.getVcName)(vc)}' unexpectedly rendered an error alert. It reads:\n\n${options.message}`);
+            }
+        };
+    },
+    assertCardRendersProgress(vc, expectedPercentComplete) {
+        var _a;
+        const model = render_utility_1.default.render(vc);
+        const progress = (0, assertSupport_1.pluckFirstFromCard)(model, 'progress');
+        test_utils_1.assert.isTruthy(progress, `I expected your card to render progress view, but it didn't!`);
+        //@ts-ignore
+        const controller = progress.controller;
+        const progressModel = render_utility_1.default.render(controller !== null && controller !== void 0 ? controller : { render: () => ({}) });
+        if (typeof expectedPercentComplete === 'number') {
+            test_utils_1.assert.isEqual(expectedPercentComplete, progressModel.percentComplete, `Expected progress to be at '${expectedPercentComplete}', but found '${(_a = progressModel.percentComplete) !== null && _a !== void 0 ? _a : 'nothing'}'`);
+        }
+        //@ts-ignore
+        return controller;
+    },
+    assertCardRendersRatings(vc) {
+        const model = render_utility_1.default.render(vc);
+        const progress = (0, assertSupport_1.pluckFirstFromCard)(model, 'ratings');
+        test_utils_1.assert.isTruthy(progress, `Expected to find a ratings view inside your card, but I didn't!`);
+        return progress.controller;
+    },
+    assertSkillViewNotScoped(vc) {
+        const actualAsArray = normalizeScopeFromVc(vc);
+        test_utils_1.assert.isEqualDeep(actualAsArray, ['none'], `Your skill view '${(0, assertSupport_1.getVcName)(vc)}' should not be scoped, but is set to '${renderScopeMarkup(actualAsArray)}'!`);
+    },
+    assertSkillViewScopedBy(vc, scopedBy) {
+        let expectedAsArray = Array.isArray(scopedBy) ? scopedBy : [scopedBy];
+        for (const scope of expectedAsArray) {
+            if (['none', 'location', 'organization', 'employed'].indexOf(scope) === -1) {
+                test_utils_1.assert.fail(`Valid scopes are 'none', 'location', 'organization', and/or 'employed'. You passed '${scopedBy}'.`);
+            }
+        }
+        const actualAsArray = normalizeScopeFromVc(vc);
+        expectedAsArray.sort();
+        actualAsArray.sort();
+        test_utils_1.assert.isEqualDeep(actualAsArray, expectedAsArray, `Your skill view '${(0, assertSupport_1.getVcName)(vc)}' is not scoped as expected. Try 'public getScope = () => ${renderScopeMarkup(expectedAsArray)} as ScopeFlag[]'!`);
+    },
+    /**
+     * @deprecated vcAssert.assertCheckboxTogglesRowEnabled(...) -> listAssert.checkboxTogglesRowEnabled(...)
+     */
+    async assertCheckboxTogglesRowEnabled(listVc, row) {
+        return listAssert_1.default.checkboxTogglesRowEnabled(listVc, row);
+    },
+    assertCardFooterIsDisabled(vc) {
+        var _a;
+        const model = render_utility_1.default.render(vc);
+        test_utils_1.assert.isFalse((_a = model.footer) === null || _a === void 0 ? void 0 : _a.isEnabled, `I expected your footer to be disabled, try setting '{ footer: { isEnabled: false } }' or 'cardVc.disableFooter()'`);
+    },
+    assertCardFooterIsEnabled(vc) {
+        var _a;
+        const model = render_utility_1.default.render(vc);
+        test_utils_1.assert.isTrue(((_a = model.footer) === null || _a === void 0 ? void 0 : _a.isEnabled) !== false, `I expected your footer to be enabled, try setting '{ footer: { isEnabled: true } }' or 'cardVc.enableFooter()'`);
+    },
+    /**
+     * @deprecated vcAssert.assertRowIsStyle(...) -> listAssert.rowIsStyle(...)
+     */
+    assertRowIsStyle(vc, row, style) {
+        return listAssert_1.default.rowIsStyle(vc, row, style);
+    },
+};
+exports.default = vcAssert;
+function renderScopeMarkup(expectedAsArray) {
+    return `['${expectedAsArray.join("','")}']`;
+}
+function normalizeScopeFromVc(vc) {
+    var _a, _b, _c;
+    const actual = (_a = vc.getScopedBy) === null || _a === void 0 ? void 0 : _a.call(vc);
+    const actualAsArray = actual ? [actual] : (_c = (_b = vc.getScope) === null || _b === void 0 ? void 0 : _b.call(vc)) !== null && _c !== void 0 ? _c : [];
+    if (actualAsArray.length === 0) {
+        actualAsArray.push('none');
+    }
+    return actualAsArray;
+}
+exports.normalizeScopeFromVc = normalizeScopeFromVc;
+function checkForCardSection(vc, sectionIdOrIdx) {
+    var _a, _b;
+    const model = render_utility_1.default.render(vc);
+    const sections = (_b = (_a = model.body) === null || _a === void 0 ? void 0 : _a.sections) !== null && _b !== void 0 ? _b : [];
+    const idx = (0, sectionIdOrIdxToIdx_1.default)(sections, sectionIdOrIdx);
+    const match = sections[idx];
+    test_utils_1.assert.isTruthy(match, `I could not find a section called '${sectionIdOrIdx}' in your card!`);
+    return match;
+}
+function checkForButtons(vc, ids) {
+    var _a, _b;
+    (0, schema_1.assertOptions)({ vc, ids }, ['vc', 'ids']);
+    const model = render_utility_1.default.render(vc);
+    const buttons = [...((_b = (_a = model.footer) === null || _a === void 0 ? void 0 : _a.buttons) !== null && _b !== void 0 ? _b : [])];
+    (0, assertSupport_1.pluckAllFromCard)(model, 'buttons').forEach((b) => {
+        if (b) {
+            buttons.push(...b);
+        }
+    });
+    const missing = [];
+    const found = [];
+    const foundButtons = [];
+    for (const id of ids) {
+        const match = buttons.find((b) => (b === null || b === void 0 ? void 0 : b.id) === id);
+        if (!match) {
+            missing.push(id);
+        }
+        else {
+            found.push(id);
+            foundButtons.push(match);
+        }
+    }
+    return { found, missing, foundButtons };
+}
+function findControllerInModel(VcClass, model) {
+    var _a, _b, _c;
+    if ((model === null || model === void 0 ? void 0 : model.controller) instanceof VcClass) {
+        return model === null || model === void 0 ? void 0 : model.controller;
+    }
+    if (VcClass.name.toLowerCase().includes(
+    //@ts-ignore
+    (_c = (_b = (_a = model === null || model === void 0 ? void 0 : model.controller) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.toLowerCase()) !== null && _c !== void 0 ? _c : '******nope')) {
+        return model === null || model === void 0 ? void 0 : model.controller;
+    }
+    return null;
+}