@sprucelabs/spruce-cli 19.0.0 → 19.1.0

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/tests/utilities/autocompleteAssert.d.ts

@@ -0,0 +1,16 @@
+import AutocompleteInputViewController from '../../viewControllers/form/AutocompleteInput.vc';
+declare const autocompleteAssert: {
+    /**
+     * @deprecated autocompleteAssert.assertActionShowsSuggestions(...) -> autocompleteAssert.actionShowsSuggestions(...)
+     */
+    assertActionShowsSuggestions(vc: AutocompleteInputViewController, action: () => Promise<any> | any, expectedSuggestionIds?: string[]): Promise<void>;
+    actionShowsSuggestions(vc: AutocompleteInputViewController, action: () => Promise<any> | any, expectedSuggestionIds?: string[]): Promise<void>;
+    /**
+     * @deprecated autocompleteAssert.assertActionHidesSuggestions(...) -> autocompleteAssert.actionHidesSuggestions(...)
+     */
+    assertActionHidesSuggestions(vc: AutocompleteInputViewController, action: () => Promise<any> | any): Promise<void>;
+    actionHidesSuggestions(vc: AutocompleteInputViewController, action: () => Promise<any> | any): Promise<void>;
+    suggestionIsShowing(vc: AutocompleteInputViewController, suggestionId: string): void;
+    suggestionIsNotShowing(vc: AutocompleteInputViewController, suggestionId: string): void;
+};
+export default autocompleteAssert;

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

@@ -0,0 +1,79 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { assertOptions } from '@sprucelabs/schema';
+import { assert } from '@sprucelabs/test-utils';
+import renderUtil from '../../utilities/render.utility.js';
+const autocompleteAssert = {
+    /**
+     * @deprecated autocompleteAssert.assertActionShowsSuggestions(...) -> autocompleteAssert.actionShowsSuggestions(...)
+     */
+    assertActionShowsSuggestions(vc, action, expectedSuggestionIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.actionShowsSuggestions(vc, action, expectedSuggestionIds);
+        });
+    },
+    actionShowsSuggestions(vc, action, expectedSuggestionIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            assertOptions({ vc, action }, ['vc', 'action']);
+            let wasHit = false;
+            let passedSuggestions = [];
+            const original = vc.showSuggestions.bind(vc);
+            vc.showSuggestions = (suggestions) => {
+                wasHit = true;
+                passedSuggestions = suggestions;
+                return original(suggestions);
+            };
+            yield action();
+            if (expectedSuggestionIds) {
+                const actual = passedSuggestions.map((s) => s.id);
+                actual.sort();
+                expectedSuggestionIds.sort();
+                assert.isEqualDeep(actual, expectedSuggestionIds, `The suggestions you passed do not match what I expected!`);
+            }
+            assert.isTrue(wasHit, `I expected you to call 'vc.showSuggestions(...)', but you didn't!`);
+        });
+    },
+    /**
+     * @deprecated autocompleteAssert.assertActionHidesSuggestions(...) -> autocompleteAssert.actionHidesSuggestions(...)
+     */
+    assertActionHidesSuggestions(vc, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.actionHidesSuggestions(vc, action);
+        });
+    },
+    actionHidesSuggestions(vc, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            assertOptions({ vc, action }, ['vc', 'action']);
+            let wasHit = false;
+            vc.hideSuggestions = () => {
+                wasHit = true;
+            };
+            yield action();
+            assert.isTruthy(wasHit, `A was waiting for you to call 'vc.hideSuggestions()', but it never happened!`);
+        });
+    },
+    suggestionIsShowing(vc, suggestionId) {
+        assertOptions({ vc, suggestionId }, ['vc', 'suggestionId']);
+        assert.isTrue(vc.getIsShowingSuggestions(), "You aren't showing an suggestions. Try 'vc.showSuggestions(...)' to show suggestions!");
+        const { suggestions } = renderUtil.render(vc);
+        assert.isTruthy(suggestions === null || suggestions === void 0 ? void 0 : suggestions.find((s) => s.id === suggestionId), `I could not find a suggestion with the id of '${suggestionId}'!`);
+    },
+    suggestionIsNotShowing(vc, suggestionId) {
+        assertOptions({ vc, suggestionId }, ['vc', 'suggestionId']);
+        try {
+            this.suggestionIsShowing(vc, suggestionId);
+        }
+        catch (_a) {
+            return;
+        }
+        assert.fail(`I found a suggestion with the id of '${suggestionId}' and didn't expect to!`);
+    },
+};
+export default autocompleteAssert;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/tests/utilities/autocompleteInteractor.d.ts

@@ -0,0 +1,5 @@
+import AutocompleteInputViewController from '../../viewControllers/form/AutocompleteInput.vc';
+declare const autocompleteInteractor: {
+    clickSuggestion(vc: AutocompleteInputViewController, suggestionId: string): Promise<void>;
+};
+export default autocompleteInteractor;

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

@@ -0,0 +1,27 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { assertOptions } from '@sprucelabs/schema';
+import { assert } from '@sprucelabs/test-utils';
+import renderUtil from '../../utilities/render.utility.js';
+const autocompleteInteractor = {
+    clickSuggestion(vc, suggestionId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            assertOptions({ vc, suggestionId }, ['vc', 'suggestionId']);
+            assert.isTrue(vc.getIsShowingSuggestions(), `You can't click a suggestion until suggestions are showing, try 'vc.showSuggestions(...)'`);
+            const model = renderUtil.render(vc);
+            const match = (_a = model.suggestions) === null || _a === void 0 ? void 0 : _a.find((s) => s.id === suggestionId);
+            assert.isTruthy(match, `I could not find a suggestion with the id '${suggestionId}'!`);
+            assert.isFunction(match.onClick, `I could not click your suggestion because it does not have an 'onClick' set!`);
+            yield match.onClick(suggestionId);
+        });
+    },
+};
+export default autocompleteInteractor;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/tests/utilities/calendarInteractor.d.ts

@@ -0,0 +1,8 @@
+import { Calendar, ClickCalendarViewOptions, ViewController } from '../../types/heartwood.types';
+declare const calendarInteractor: {
+    longPressThenDrop(vc: ViewController<Calendar>, options?: ClickCalendarViewOptions): Promise<void>;
+    tapView(vc: ViewController<Calendar>, options?: ClickCalendarViewOptions): Promise<void>;
+    clickMonthView(vc: ViewController<Calendar>, dateTimeMs: number): Promise<void>;
+    clickDayView(vc: ViewController<Calendar>, dateTimeMs: number, personId?: string): Promise<void>;
+};
+export default calendarInteractor;

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

@@ -0,0 +1,60 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { dateUtil } from '@sprucelabs/calendar-utils';
+import { assertOptions } from '@sprucelabs/schema';
+import { assert } from '@sprucelabs/test-utils';
+import renderUtil from '../../utilities/render.utility.js';
+import { getVcName } from './assertSupport.js';
+const calendarInteractor = {
+    longPressThenDrop(vc, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { onLongPressViewDrop } = renderUtil.render(vc);
+            assert.isTruthy(onLongPressViewDrop, `You gotta set 'onLongPressViewDrop' in your calendar's constructor options.`);
+            yield (onLongPressViewDrop === null || onLongPressViewDrop === void 0 ? void 0 : onLongPressViewDrop(Object.assign({}, options)));
+        });
+    },
+    tapView(vc, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { onTapView } = renderUtil.render(vc);
+            assert.isTruthy(onTapView, `You gotta set 'onTapView' in your calendar's constructor options.`);
+            yield (onTapView === null || onTapView === void 0 ? void 0 : onTapView(Object.assign({}, options)));
+        });
+    },
+    clickMonthView(vc, dateTimeMs) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            assertOptions({ vc, dateTimeMs }, ['vc', 'dateTimeMs']);
+            const model = renderUtil.render(vc);
+            assert.isEqual(model.view, 'month', `Your calendar '${getVcName(vc)}' needs it's view set to 'month', it's currently set to ${(_a = model.view) !== null && _a !== void 0 ? _a : '***empty***'}`);
+            assert.isFunction(model.onClickView, `You have to set 'onClickView' on your calendar!`);
+            yield ((_b = model.onClickView) === null || _b === void 0 ? void 0 : _b.call(model, {
+                dateTimeMs: dateUtil.getStartOfDay(dateTimeMs),
+            }));
+        });
+    },
+    clickDayView(vc, dateTimeMs, personId) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            assertOptions({ vc, dateTimeMs }, ['vc', 'dateTimeMs']);
+            const model = renderUtil.render(vc);
+            assert.isEqual(model.view, 'day', `Your calendar '${getVcName(vc)}' needs it's view set to 'day', it's currently set to ${(_a = model.view) !== null && _a !== void 0 ? _a : '***empty***'}`);
+            if (personId) {
+                const personMatch = (_b = model === null || model === void 0 ? void 0 : model.people) === null || _b === void 0 ? void 0 : _b.find((p) => (p === null || p === void 0 ? void 0 : p.id) === personId);
+                assert.isTruthy(personMatch, `I could not find a person with the id of ${personId}.`);
+            }
+            assert.isFunction(model.onClickView, `You have to set 'onClick' on your calendar!`);
+            yield ((_c = model.onClickView) === null || _c === void 0 ? void 0 : _c.call(model, {
+                dateTimeMs,
+                personId,
+            }));
+        });
+    },
+};
+export default calendarInteractor;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/tests/utilities/calendarSeeder.d.ts

@@ -0,0 +1,9 @@
+import { SpruceSchemas } from '../..';
+type Event = Omit<SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent, 'isSelected'>;
+declare const calendarSeeder: {
+    generatePeopleValues(total: number): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarPerson[];
+    generatePersonValues(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarPerson;
+    generateEventsValues(total: number): Event[];
+    generateEventValues(values?: Partial<Event>): Event;
+};
+export default calendarSeeder;

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

@@ -0,0 +1,39 @@
+import { dateUtil } from '@sprucelabs/calendar-utils';
+let idCount = 0;
+const calendarSeeder = {
+    generatePeopleValues(total) {
+        return new Array(total).fill(0).map(() => this.generatePersonValues());
+    },
+    generatePersonValues() {
+        return {
+            id: `${random()}`,
+            casualName: 'Timmy',
+        };
+    },
+    generateEventsValues(total) {
+        return new Array(total)
+            .fill(0)
+            .map(() => calendarSeeder.generateEventValues());
+    },
+    generateEventValues(values) {
+        const blocks = [1, 3];
+        const totalTimeBlocks = blocks[Math.round(Math.random())];
+        const hour = Math.round(Math.random() * 8) + 9;
+        return Object.assign({ id: `${random()}-${idCount++}`, startDateTimeMs: dateUtil.setTimeOfDay(new Date().getTime(), hour, generateRandomMinutes(45), 0, 0), target: {
+                personId: `${random()}`,
+                locationId: `${random()}`,
+            }, calendarId: `${random()}`, timeBlocks: new Array(totalTimeBlocks).fill(0).map((_, idx) => ({
+                durationMinutes: generateRandomMinutes(75),
+                isBusy: !(idx % 2),
+                title: `Block ${random()}-${idCount++}`,
+                subtitle: `Subtitle ${random()}-${idCount++}`,
+            })) }, values);
+    },
+};
+export default calendarSeeder;
+function random() {
+    return new Date().getTime() * Math.random();
+}
+function generateRandomMinutes(maxMinutes) {
+    return Math.round((Math.random() * maxMinutes + 15) / 15) * 15;
+}

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/tests/utilities/confirmTestPatcher.d.ts

@@ -0,0 +1,5 @@
+import { AbstractViewController } from '../..';
+declare const confirmTestPatcher: {
+    patchConfirmToThrow(vc: AbstractViewController<any>): void;
+};
+export default confirmTestPatcher;

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

@@ -0,0 +1,22 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { assert } from '@sprucelabs/test-utils';
+const confirmTestPatcher = {
+    patchConfirmToThrow(vc) {
+        var _a;
+        //@ts-ignore
+        vc._originalConfirm = (_a = vc.confirm) === null || _a === void 0 ? void 0 : _a.bind(vc);
+        //@ts-ignore
+        vc.confirm = () => __awaiter(this, void 0, void 0, function* () {
+            assert.fail(`Your view controller unexpectedly rendered a confirm! If this was intentional, use 'await vcAssert.assertRendersConfirm(this.vc, () => ...)'`);
+        });
+    },
+};
+export default confirmTestPatcher;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/tests/utilities/deviceAssert.d.ts

@@ -0,0 +1,6 @@
+import AbstractViewController from '../../viewControllers/Abstract.vc';
+declare const deviceAssert: {
+    assertWasVibrated(vc: AbstractViewController<any>): void;
+    assertWasNotVibrated(vc: AbstractViewController<any>): void;
+};
+export default deviceAssert;

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

@@ -0,0 +1,21 @@
+import { assertOptions } from '@sprucelabs/schema';
+import { assert } from '@sprucelabs/test-utils';
+const deviceAssert = {
+    assertWasVibrated(vc) {
+        assertOptions({ vc }, ['vc']);
+        //@ts-ignore
+        const device = vc.getDevice();
+        assert.isAbove(device.vibrateCount, 0, "I expected you to vibrate the device and you didn't! What's up, you don't like fun?");
+    },
+    assertWasNotVibrated(vc) {
+        assertOptions({ vc }, ['vc']);
+        try {
+            this.assertWasVibrated(vc);
+        }
+        catch (_a) {
+            return;
+        }
+        assert.fail(`You vibrated the device and should not have! Getting a little excited I see!`);
+    },
+};
+export default deviceAssert;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/tests/utilities/dialogTestPatcher.d.ts

@@ -0,0 +1,5 @@
+import AbstractViewController from '../../viewControllers/Abstract.vc';
+declare const dialogTestPatcher: {
+    patchDialogToThrow(vc: AbstractViewController<any>): void;
+};
+export default dialogTestPatcher;

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

@@ -0,0 +1,13 @@
+import { assert } from '@sprucelabs/test-utils';
+const dialogTestPatcher = {
+    patchDialogToThrow(vc) {
+        var _a;
+        //@ts-ignore
+        vc._originalRenderInDialog = (_a = vc.renderInDialog) === null || _a === void 0 ? void 0 : _a.bind(vc);
+        //@ts-ignore
+        vc.renderInDialog = () => {
+            assert.fail(`You unexpectedly rendered a dialog. If this was on purpose, use await vcAssert.assertRendersDialog(). If this was a mistake, remember, there are only happy accidents. Also, stop this dialog from rendering.`);
+        };
+    },
+};
+export default dialogTestPatcher;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/tests/utilities/feedAssert.d.ts

@@ -0,0 +1,6 @@
+import { Card, ViewController } from '../../types/heartwood.types';
+import FeedViewController from '../../viewControllers/Feed.vc';
+declare const feedAssert: {
+    cardRendersFeed(vc: ViewController<Card>): FeedViewController;
+};
+export default feedAssert;

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

@@ -0,0 +1,14 @@
+import { assertOptions } from '@sprucelabs/schema';
+import { assert } from '@sprucelabs/test-utils';
+import renderUtil from '../../utilities/render.utility.js';
+import { pluckFirstFromCard } from './assertSupport.js';
+const feedAssert = {
+    cardRendersFeed(vc) {
+        assertOptions({ vc }, ['vc']);
+        const model = renderUtil.render(vc);
+        const feed = pluckFirstFromCard(model, 'feed');
+        assert.isTruthy(feed === null || feed === void 0 ? void 0 : feed.controller, `Your card does not render a feed view!`);
+        return feed.controller;
+    },
+};
+export default feedAssert;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/tests/utilities/feedInteractor.d.ts

@@ -0,0 +1,5 @@
+import { Feed, ViewController } from '../../types/heartwood.types';
+declare const feedInteractor: {
+    submitMessage(vc: ViewController<Feed>, message: string): Promise<boolean | void>;
+};
+export default feedInteractor;

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

@@ -0,0 +1,23 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { assertOptions } from '@sprucelabs/schema';
+import { assert } from '@sprucelabs/test-utils';
+import renderUtil from '../../utilities/render.utility.js';
+const feedInteractor = {
+    submitMessage(vc, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            assertOptions({ vc, message }, ['vc', 'message']);
+            const { onSubmitMessage } = renderUtil.render(vc);
+            assert.isTruthy(onSubmitMessage, `Make sure you set a handler for 'onSubmitMessage: () => boolean | Promise<boolean>'`);
+            return yield onSubmitMessage(message);
+        });
+    },
+};
+export default feedInteractor;

package/node_modules/@sprucelabs/heartwood-view-controllers/build/esm/tests/utilities/formAssert.d.ts

@@ -0,0 +1,29 @@
+import { FieldDefinitions } from '@sprucelabs/schema';
+import { BigFormViewController, Card, FormBuilderCardViewController, FormInputViewController, FormViewController, RenderAsComponent, SkillViewController, ViewController } from '../../types/heartwood.types';
+import DialogViewController from '../../viewControllers/Dialog.vc';
+import ViewControllerFactory from '../../viewControllers/ViewControllerFactory';
+declare const formAssert: {
+    views: SimpleFactory;
+    _setVcFactory(views: SimpleFactory): void;
+    inputVcIsValid(inputVc: FormInputViewController): Promise<void>;
+    formRendersSection(formVc: FormVc, sectionId: string): void;
+    formDoesNotRendersSection(formVc: FormVc, sectionId: string): void;
+    formRendersField(formVc: FormVc, fieldName: string, fieldDefinition?: Partial<FieldDefinitions>): void;
+    formDoesNotRenderField(formVc: FormVc, fieldName: string): void;
+    formRendersFields(formVc: FormVc, fields: string[]): void;
+    formIsDisabled(vc: FormVc): void;
+    formIsEnabled(vc: FormVc): void;
+    formIsBusy(vc: FormVc): void;
+    formIsNotBusy(vc: FormVc): void;
+    cardRendersForm(vc: ViewController<Card> | DialogViewController): FormViewController<any> | BigFormViewController<any>;
+    cardRendersForms(vc: ViewController<Card>, count: number): FormViewController<any>[] | BigFormViewController<any>[];
+    formFieldRendersUsingInputVc(vc: FormVc, fieldName: string, inputVc: FormInputViewController): void;
+    fieldRendersUsingInstanceOf(vc: FormVc, fieldName: string, Class: new (options: any) => FormInputViewController): void;
+    skillViewRendersFormBuilder(vc: SkillViewController, id?: string): FormBuilderCardViewController;
+    formFieldRendersAs(vc: FormVc, fieldName: string, expected: RenderAsComponent): void;
+};
+type FormAssert = Omit<typeof formAssert, 'views' | '_setVcFactory'>;
+declare const _default: FormAssert;
+export default _default;
+type SimpleFactory = Pick<ViewControllerFactory, 'Controller'>;
+export type FormVc = FormViewController<any> | BigFormViewController<any>;

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

@@ -0,0 +1,212 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { assertOptions, buildSchema, } from '@sprucelabs/schema';
+import { assert } from '@sprucelabs/test-utils';
+import { generateId } from '@sprucelabs/test-utils';
+import buildForm from '../../builders/buildForm.js';
+import normalizeFormSectionFieldNamesUtil from '../../utilities/normalizeFieldNames.utility.js';
+import renderUtil from '../../utilities/render.utility.js';
+import FormViewControllerImpl from '../../viewControllers/form/Form.vc.js';
+import { pluckFirstFromCard } from './assertSupport.js';
+const formAssert = {
+    views: {},
+    _setVcFactory(views) {
+        this.views = views;
+    },
+    inputVcIsValid(inputVc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert.isFunction(inputVc.getValue, `You gotta create a 'getValue()' method on your input! Or consider having your vc extend AbstractFormInputViewController and be done! 💪`);
+            assert.isFunction(inputVc.setValue, `You gotta create a 'setValue()' method on your input!`);
+            assert.isFunction(inputVc.setHandlers, `You need to create a 'setHandlers(...)' method that conforms to FormInputViewController. Consider extending AbstractFormInputViewController to skip all this.`);
+            const formVc = BuildFormVc(this.views, inputVc);
+            let value = generateId();
+            yield inputVc.setValue(value);
+            assert.isEqual(formVc.getValue('field'), value, `You need to make sure 'setValue()' returns 'this.setValueHandler()' from your input.`);
+            value = generateId();
+            yield formVc.setValue('field', value);
+            assert.isEqual(inputVc.getValue(), value, `You need to make sure 'getValue()' returns 'this.getValueHandler()' from your input.`);
+            assert.isFunction(inputVc.getRenderedValue, `You need to implement 'getRenderedValue(...)' on your input!`);
+            assert.isFunction(inputVc.setRenderedValue, `You need to implement 'setRenderedValue(...)' on your input!`);
+        });
+    },
+    formRendersSection(formVc, sectionId) {
+        const model = renderUtil.render(formVc);
+        const match = model.sections.find((s) => s.id === sectionId);
+        assert.isTruthy(match, `I could not find section '${sectionId}' in your form!`);
+    },
+    formDoesNotRendersSection(formVc, sectionId) {
+        try {
+            this.formRendersSection(formVc, sectionId);
+        }
+        catch (_a) {
+            return;
+        }
+        assert.fail(`I found section '${sectionId}' in your form and did not expect to!`);
+    },
+    formRendersField(formVc, fieldName, fieldDefinition) {
+        const model = renderUtil.render(formVc);
+        const schema = formVc.getSchema();
+        for (const section of model.sections) {
+            const fields = normalizeFormSectionFieldNamesUtil.toObjects(section.fields, schema);
+            const match = fields.find((n) => n.name === fieldName);
+            if (match) {
+                if (fieldDefinition) {
+                    assert.doesInclude(match, fieldDefinition);
+                }
+                return;
+            }
+        }
+        assert.fail(`Form does not render field named '${fieldName}'. Make sure it's in your form's schema and set in 'form.sections.fields'.`);
+    },
+    formDoesNotRenderField(formVc, fieldName) {
+        try {
+            this.formRendersField(formVc, fieldName);
+        }
+        catch (_a) {
+            return;
+        }
+        assert.fail(`Form should not be rendering '${fieldName}', but it is.`);
+    },
+    formRendersFields(formVc, fields) {
+        for (const field of fields) {
+            this.formRendersField(formVc, field);
+        }
+    },
+    formIsDisabled(vc) {
+        assert.isFalse(vc.isEnabled(), 'Your form is enabled and it should not be! Try this.formVc.disable()');
+    },
+    formIsEnabled(vc) {
+        assert.isTrue(vc.isEnabled(), 'Your form is not yet enabled! Try this.formVc.enable()');
+    },
+    formIsBusy(vc) {
+        assert.isTrue(vc.getIsBusy(), 'Your form is not busy and should be! Try this.formVc.setIsBusy(true).');
+    },
+    formIsNotBusy(vc) {
+        assert.isFalse(vc.getIsBusy(), 'Your form is still busy. Try this.formVc.setIsBusy(false) to stop it!');
+    },
+    cardRendersForm(vc) {
+        const model = renderUtil.render(vc);
+        const form = pluckFirstFromCard(model, 'bigForm') || pluckFirstFromCard(model, 'form');
+        assert.isTrue((form === null || form === void 0 ? void 0 : form.controller) instanceof FormViewControllerImpl, "Expected to find a form inside your CardViewController, but didn't find one!");
+        return form === null || form === void 0 ? void 0 : form.controller;
+    },
+    cardRendersForms(vc, count) {
+        var _a, _b, _c;
+        const model = renderUtil.render(vc);
+        const forms = (_c = (_b = (_a = model.body) === null || _a === void 0 ? void 0 : _a.sections) === null || _b === void 0 ? void 0 : _b.map((s) => { var _a, _b, _c; return (_b = (_a = s.form) === null || _a === void 0 ? void 0 : _a.controller) !== null && _b !== void 0 ? _b : (_c = s.bigForm) === null || _c === void 0 ? void 0 : _c.controller; }).filter((s) => !!s)) !== null && _c !== void 0 ? _c : [];
+        if (forms.length !== count) {
+            assert.fail(`Expected your card to render ${count} form${count === 1 ? '' : 's'}, but I found ${forms.length === 0 ? 'none' : forms.length}!`);
+        }
+        return forms;
+    },
+    formFieldRendersUsingInputVc(vc, fieldName, inputVc) {
+        try {
+            vc.getField(fieldName);
+        }
+        catch (_a) {
+            assert.fail(`I could not find a field called '${fieldName}' on your form!`);
+        }
+        const match = vc.getFieldVc(fieldName);
+        assert.isEqual(match, inputVc, `Your field did not render using the input vc you passed. Make sure you are setting the vc when creating your form vc!
+		
+		
+		
+this.Controller(
+	'form',
+	buildForm({
+		schema: formSchema,
+		sections: [
+			{
+				fields: [
+					{
+						name: 'firstName',
+						vc: this.myInputVc, <----- drop it in here
+					},
+				],
+			},
+		],
+	})
+)`);
+    },
+    fieldRendersUsingInstanceOf(vc, fieldName, Class) {
+        try {
+            vc.getField(fieldName);
+        }
+        catch (_a) {
+            assert.fail(`I could not find a field called '${fieldName}' on your form!`);
+        }
+        const match = vc.getFieldVc(fieldName);
+        assert.isTrue(match instanceof Class, `Your field did not render using the input vc you passed. Make sure you are setting the vc when creating your form vc!
+		
+		
+		
+this.Controller(
+	'form',
+	buildForm({
+		schema: formSchema,
+		sections: [
+			{
+				fields: [
+					{
+						name: 'firstName',
+						vc: this.myInputVc, <----- drop it in here
+					},
+				],
+			},
+		],
+	})
+)`);
+    },
+    skillViewRendersFormBuilder(vc, id) {
+        var _a;
+        const model = renderUtil.render(vc);
+        for (const layout of model.layouts) {
+            for (const card of (_a = layout.cards) !== null && _a !== void 0 ? _a : []) {
+                const vc = card === null || card === void 0 ? void 0 : card.controller;
+                //@ts-ignore
+                if (vc && vc.__isFormBuilder && (!id || card.id === id)) {
+                    return vc;
+                }
+            }
+        }
+        assert.fail(`Could not find a form builder${id ? ` with the id ${id}` : ''} in your skill view!`);
+        return {};
+    },
+    formFieldRendersAs(vc, fieldName, expected) {
+        var _a;
+        assertOptions({ vc, fieldName, expected }, ['vc', 'fieldName', 'expected']);
+        const field = vc.getField(fieldName);
+        assert.isEqual(field.compiledOptions.renderAs, expected, `The field named '${fieldName}' is rendering as '${(_a = field.compiledOptions.renderAs) !== null && _a !== void 0 ? _a : '***default**'}', but I expected it to render as '${expected}'!`);
+    },
+};
+function BuildFormVc(views, inputVc) {
+    return views.Controller('form', buildForm({
+        schema: formSchema,
+        sections: [
+            {
+                fields: [
+                    {
+                        name: 'field',
+                        vc: inputVc,
+                    },
+                ],
+            },
+        ],
+    }));
+}
+export default formAssert;
+const formSchema = buildSchema({
+    id: 'formAssertTest',
+    fields: {
+        field: {
+            type: 'text',
+        },
+    },
+});