@sprucelabs/heartwood-view-controllers 126.6.1 → 126.7.1

package/README.md

@@ -17,6 +17,6 @@ Spruce XP Documentation
 <p align="center">
 <a href="https://developer.spruce.ai/#/"><img width="250" src="https://raw.githubusercontent.com/sprucelabsai/heartwood-view-contrhollers/master/docs/images/read-full-docs.png" /></a>
 </p>
-### Dependencies
-[Arkit diagram here](docs/dependencies.md).
 
+### Dependencies
+[Arkit diagram here](docs/dependencies.md).

package/build/__tests__/behavioral/AssertingScope.test.d.ts

@@ -0,0 +1,35 @@
+import { SpruceSchemas } from '@sprucelabs/mercury-types';
+import { AbstractSkillViewController, ScopedBy, ScopeFlag } from '../..';
+import AbstractViewControllerTest from '../../tests/AbstractViewControllerTest';
+declare class Scope extends AbstractSkillViewController {
+    private scope?;
+    constructor(options: any);
+    getScopedBy(): ScopedBy;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.SkillView;
+}
+declare class ScopeFlagVc extends AbstractSkillViewController {
+    private scope?;
+    constructor(options: any);
+    getScope(): ScopeFlag[];
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.SkillView;
+}
+export default class AssertingScopeTest extends AbstractViewControllerTest {
+    protected controllerMap: {
+        scope: typeof Scope;
+        scopeFlagVc: typeof ScopeFlagVc;
+    };
+    protected scopeMustBeValued(): void;
+    protected scopeFlagMustBeValid(): void;
+    protected scopeIsDefaultToNone(): void;
+    protected scopeFagDefaultsToNothing(): void;
+    protected knowsIfScopedBySomething(scope: ScopedBy): void;
+    protected knowsIfScopedByFlag(scope: ScopeFlag[]): void;
+    protected matchesOutOfOrder(): void;
+    protected scopeToNoneCountsAsNotScoped(): void;
+    protected emptyFlagsCountsAsNone(): void;
+    protected throwsIfScopedBySomethingElse(): void;
+    protected throwsIfScopedFlagsDontMatch(): void;
+    private Vc;
+    private FlagVc;
+}
+export {};

package/build/__tests__/behavioral/AssertingScope.test.js

@@ -0,0 +1,162 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_utils_1 = require("@sprucelabs/test-utils");
+const __1 = require("../..");
+const AbstractViewControllerTest_1 = __importDefault(require("../../tests/AbstractViewControllerTest"));
+class Scope extends __1.AbstractSkillViewController {
+    constructor(options) {
+        super(options);
+        this.scope = options.scope;
+    }
+    getScopedBy() {
+        return this.scope ?? 'none';
+    }
+    render() {
+        return {
+            layouts: [],
+        };
+    }
+}
+class ScopeFlagVc extends __1.AbstractSkillViewController {
+    constructor(options) {
+        super(options);
+        this.scope = options.scope;
+    }
+    getScope() {
+        return this.scope ?? [];
+    }
+    render() {
+        return {
+            layouts: [],
+        };
+    }
+}
+let AssertingScopeTest = class AssertingScopeTest extends AbstractViewControllerTest_1.default {
+    constructor() {
+        super(...arguments);
+        this.controllerMap = {
+            scope: Scope,
+            scopeFlagVc: ScopeFlagVc,
+        };
+    }
+    scopeMustBeValued() {
+        test_utils_1.assert.doesThrow(() => __1.vcAssert.assertSkillViewScopedBy(this.Vc('organization'), 
+        //@ts-ignore
+        'aoeuaoeu'));
+        test_utils_1.assert.doesThrow(() => __1.vcAssert.assertSkillViewScopedBy(this.Vc('organization'), 
+        //@ts-ignore
+        '523423423'));
+    }
+    scopeFlagMustBeValid() {
+        test_utils_1.assert.doesThrow(() => 
+        //@ts-ignore
+        __1.vcAssert.assertSkillViewScopedBy(this.FlagVc('organization'), [
+            'aoeuaoeu',
+        ]));
+        test_utils_1.assert.doesThrow(() => 
+        //@ts-ignore
+        __1.vcAssert.assertSkillViewScopedBy(this.FlagVc('organization'), [
+            'organization',
+            'aoeuaoeu',
+        ]));
+    }
+    scopeIsDefaultToNone() {
+        __1.vcAssert.assertSkillViewNotScoped(this.Vc());
+    }
+    scopeFagDefaultsToNothing() {
+        __1.vcAssert.assertSkillViewNotScoped(this.FlagVc());
+    }
+    knowsIfScopedBySomething(scope) {
+        const vc = this.Vc(scope);
+        test_utils_1.assert.doesThrow(() => __1.vcAssert.assertSkillViewNotScoped(vc));
+        __1.vcAssert.assertSkillViewScopedBy(vc, scope);
+    }
+    knowsIfScopedByFlag(scope) {
+        const vc = this.FlagVc(scope);
+        test_utils_1.assert.doesThrow(() => __1.vcAssert.assertSkillViewNotScoped(vc));
+        __1.vcAssert.assertSkillViewScopedBy(vc, scope);
+    }
+    matchesOutOfOrder() {
+        const vc = this.FlagVc(['organization', 'employed']);
+        test_utils_1.assert.doesThrow(() => __1.vcAssert.assertSkillViewNotScoped(vc));
+        __1.vcAssert.assertSkillViewScopedBy(vc, ['employed', 'organization']);
+    }
+    scopeToNoneCountsAsNotScoped() {
+        const vc = this.Vc('none');
+        __1.vcAssert.assertSkillViewNotScoped(vc);
+    }
+    emptyFlagsCountsAsNone() {
+        const vc = this.FlagVc([]);
+        __1.vcAssert.assertSkillViewNotScoped(vc);
+    }
+    throwsIfScopedBySomethingElse() {
+        const vc = this.Vc('organization');
+        test_utils_1.assert.doesThrow(() => __1.vcAssert.assertSkillViewScopedBy(vc, 'location'));
+    }
+    throwsIfScopedFlagsDontMatch() {
+        const vc = this.FlagVc(['organization']);
+        test_utils_1.assert.doesThrow(() => __1.vcAssert.assertSkillViewScopedBy(vc, ['location']));
+    }
+    Vc(scope) {
+        return this.Controller('scope', {
+            scope,
+        });
+    }
+    FlagVc(scope) {
+        return this.Controller('scopeFlagVc', {
+            scope,
+        });
+    }
+};
+__decorate([
+    (0, test_utils_1.test)()
+], AssertingScopeTest.prototype, "scopeMustBeValued", null);
+__decorate([
+    (0, test_utils_1.test)()
+], AssertingScopeTest.prototype, "scopeFlagMustBeValid", null);
+__decorate([
+    (0, test_utils_1.test)()
+], AssertingScopeTest.prototype, "scopeIsDefaultToNone", null);
+__decorate([
+    (0, test_utils_1.test)()
+], AssertingScopeTest.prototype, "scopeFagDefaultsToNothing", null);
+__decorate([
+    (0, test_utils_1.test)('knows if scoped by location', 'location'),
+    (0, test_utils_1.test)('knows if scoped by organization', 'organization')
+], AssertingScopeTest.prototype, "knowsIfScopedBySomething", null);
+__decorate([
+    (0, test_utils_1.test)('knows if scoped by location flag', ['location']),
+    (0, test_utils_1.test)('knows if scoped by organization flag', ['organization']),
+    (0, test_utils_1.test)('knows if scoped by organization, employed flag', [
+        'organization',
+        'employed',
+    ])
+], AssertingScopeTest.prototype, "knowsIfScopedByFlag", null);
+__decorate([
+    (0, test_utils_1.test)()
+], AssertingScopeTest.prototype, "matchesOutOfOrder", null);
+__decorate([
+    (0, test_utils_1.test)()
+], AssertingScopeTest.prototype, "scopeToNoneCountsAsNotScoped", null);
+__decorate([
+    (0, test_utils_1.test)()
+], AssertingScopeTest.prototype, "emptyFlagsCountsAsNone", null);
+__decorate([
+    (0, test_utils_1.test)()
+], AssertingScopeTest.prototype, "throwsIfScopedBySomethingElse", null);
+__decorate([
+    (0, test_utils_1.test)()
+], AssertingScopeTest.prototype, "throwsIfScopedFlagsDontMatch", null);
+AssertingScopeTest = __decorate([
+    (0, test_utils_1.suite)()
+], AssertingScopeTest);
+exports.default = AssertingScopeTest;

package/build/__tests__/behavioral/BuildSkillViewLayout.test.d.ts

@@ -0,0 +1,8 @@
+import AbstractSpruceTest from '@sprucelabs/test-utils';
+export default class BuildSkillViewLayoutTest extends AbstractSpruceTest {
+    protected honorsBigLeftTyping(): void;
+    protected honorsBigRightTyping(): void;
+    protected honorsBigTopTyping(): void;
+    protected honorsBigTopLeftTyping(): void;
+    protected honorsGridTyping(): void;
+}

package/build/__tests__/behavioral/BuildSkillViewLayout.test.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_utils_1 = __importStar(require("@sprucelabs/test-utils"));
+const buildSkillViewLayout_1 = __importDefault(require("../../utilities/buildSkillViewLayout"));
+let BuildSkillViewLayoutTest = class BuildSkillViewLayoutTest extends test_utils_1.default {
+    honorsBigLeftTyping() {
+        test_utils_1.assert.isType((0, buildSkillViewLayout_1.default)('big-left', {
+            leftCards: [],
+            rightCards: [],
+        }));
+    }
+    honorsBigRightTyping() {
+        test_utils_1.assert.isType((0, buildSkillViewLayout_1.default)('big-right', {
+            leftCards: [],
+            rightCards: [],
+        }));
+    }
+    honorsBigTopTyping() {
+        test_utils_1.assert.isType((0, buildSkillViewLayout_1.default)('big-top', {
+            topCards: [],
+            bottomCards: [],
+        }));
+    }
+    honorsBigTopLeftTyping() {
+        test_utils_1.assert.isType((0, buildSkillViewLayout_1.default)('big-top-left', {
+            leftCards: [],
+            rightCards: [],
+            bottomCards: [],
+        }));
+    }
+    honorsGridTyping() {
+        test_utils_1.assert.isType((0, buildSkillViewLayout_1.default)('grid', {
+            cards: [],
+        }));
+    }
+};
+__decorate([
+    (0, test_utils_1.test)()
+], BuildSkillViewLayoutTest.prototype, "honorsBigLeftTyping", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildSkillViewLayoutTest.prototype, "honorsBigRightTyping", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildSkillViewLayoutTest.prototype, "honorsBigTopTyping", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildSkillViewLayoutTest.prototype, "honorsBigTopLeftTyping", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildSkillViewLayoutTest.prototype, "honorsGridTyping", null);
+BuildSkillViewLayoutTest = __decorate([
+    (0, test_utils_1.suite)()
+], BuildSkillViewLayoutTest);
+exports.default = BuildSkillViewLayoutTest;

package/build/__tests__/behavioral/BuildingViewControllers.test.d.ts

@@ -0,0 +1,67 @@
+import { DateUtil } from '@sprucelabs/calendar-utils';
+import AbstractSkillViewController from '../../skillViewControllers/Abstract.svc';
+import AbstractViewControllerTest from '../../tests/AbstractViewControllerTest';
+import AbstractViewController from '../../viewControllers/Abstract.vc';
+interface ViewModel {
+}
+export declare class TestViewController extends AbstractViewController<ViewModel> {
+    invocations: never[];
+    constructorOptions: any;
+    constructor(options: any);
+    getDates(): DateUtil;
+    getMaps(): {
+        openNavigation(_options: import("../../types/heartwood.types").OpenNavigationOptions): void;
+    };
+    render(): {};
+}
+export declare class TestViewControllerWithId extends AbstractViewController<ViewModel> {
+    id: string;
+    invocations: never[];
+    constructorOptions: any;
+    constructor(options: any);
+    render(): {};
+}
+export declare class TestSkillViewController extends AbstractSkillViewController {
+    render(): {
+        layouts: never[];
+    };
+}
+declare module '../../types/heartwood.types' {
+    interface ViewControllerMap {
+        test: TestViewController;
+        test2: TestViewControllerWithId;
+        testSkillView: TestSkillViewController;
+    }
+}
+export default class BuildingViewControllersTest extends AbstractViewControllerTest {
+    protected controllerMap: {
+        test: typeof TestViewController;
+        testSkillView: typeof TestSkillViewController;
+    };
+    private factory;
+    private vc;
+    beforeEach(): Promise<void>;
+    protected canCreateBuildingViewControllers(): Promise<void>;
+    protected throwsWithoutSettingConnectToApiHandler(): Promise<void>;
+    protected throwsWithInvalidName(): Promise<void>;
+    protected hasController(): void;
+    protected doesNotHaveController(): void;
+    protected getsVcFactoryInConstructorOptions(): Promise<void>;
+    protected canGetVcFactory(): Promise<void>;
+    protected builtVcGetsConnectToApiHandler(): void;
+    protected canMixinControllers(): void;
+    protected controllersGetIdsSet(): void;
+    protected viewControllerGetTypesed(): void;
+    protected skillViewControllerGetTyped(): void;
+    protected throwsIfViewControllerSetsIdProperty(): void;
+    protected controllerFactoryMethod(): void;
+    protected canSetVoteHandler(): void;
+    protected canGetVcClass(id: any, Class: any): void;
+    protected datesIsDateUtil(): Promise<void>;
+    protected canPassDateUtilToFactory(): Promise<void>;
+    protected passesThroughMapsUtil(): Promise<void>;
+    protected canSetDatesLater(): Promise<void>;
+    private assertDatesPropEquals;
+    private assertDatesInContructorOptions;
+}
+export {};

package/build/__tests__/behavioral/BuildingViewControllers.test.js

@@ -0,0 +1,255 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestSkillViewController = exports.TestViewControllerWithId = exports.TestViewController = void 0;
+const calendar_utils_1 = require("@sprucelabs/calendar-utils");
+const test_utils_1 = require("@sprucelabs/test-utils");
+const test_utils_2 = require("@sprucelabs/test-utils");
+const Abstract_svc_1 = __importDefault(require("../../skillViewControllers/Abstract.svc"));
+const AbstractViewControllerTest_1 = __importDefault(require("../../tests/AbstractViewControllerTest"));
+const Abstract_vc_1 = __importDefault(require("../../viewControllers/Abstract.vc"));
+const ViewControllerFactory_1 = __importDefault(require("../../viewControllers/ViewControllerFactory"));
+class TestViewController extends Abstract_vc_1.default {
+    constructor(options) {
+        super(options);
+        this.invocations = [];
+        this.constructorOptions = options;
+    }
+    getDates() {
+        return this.dates;
+    }
+    getMaps() {
+        return this.maps;
+    }
+    render() {
+        return {};
+    }
+}
+exports.TestViewController = TestViewController;
+class TestViewControllerWithId extends Abstract_vc_1.default {
+    constructor(options) {
+        super(options);
+        this.id = 'throws';
+        this.invocations = [];
+        this.constructorOptions = options;
+    }
+    render() {
+        return {};
+    }
+}
+exports.TestViewControllerWithId = TestViewControllerWithId;
+class TestSkillViewController extends Abstract_svc_1.default {
+    render() {
+        return {
+            layouts: [],
+        };
+    }
+}
+exports.TestSkillViewController = TestSkillViewController;
+let BuildingViewControllersTest = class BuildingViewControllersTest extends AbstractViewControllerTest_1.default {
+    constructor() {
+        super(...arguments);
+        this.controllerMap = {
+            test: TestViewController,
+            testSkillView: TestSkillViewController,
+        };
+    }
+    async beforeEach() {
+        await super.beforeEach();
+        this.factory = this.Factory();
+        this.vc = this.factory.Controller('test', {});
+    }
+    async canCreateBuildingViewControllers() {
+        test_utils_1.assert.isTruthy(this.factory);
+    }
+    async throwsWithoutSettingConnectToApiHandler() {
+        const err = await test_utils_1.assert.doesThrowAsync(() => 
+        //@ts-ignore
+        ViewControllerFactory_1.default.Factory());
+        test_utils_2.errorAssert.assertError(err, 'MISSING_PARAMETERS', {
+            parameters: ['connectToApi', 'device'],
+        });
+    }
+    async throwsWithInvalidName() {
+        //@ts-ignore
+        const err = test_utils_1.assert.doesThrow(() => this.factory.Controller('bad_name'));
+        test_utils_2.errorAssert.assertError(err, 'INVALID_VIEW_CONTROLLER_NAME');
+    }
+    hasController() {
+        test_utils_1.assert.isTrue(this.factory.hasController('test'));
+    }
+    doesNotHaveController() {
+        test_utils_1.assert.isFalse(this.factory.hasController('test-not-found'));
+    }
+    async getsVcFactoryInConstructorOptions() {
+        test_utils_1.assert.isTruthy(this.vc.constructorOptions.vcFactory);
+    }
+    async canGetVcFactory() {
+        //@ts-ignore
+        test_utils_1.assert.isTruthy(this.vc.getVcFactory());
+        //@ts-ignore
+        test_utils_1.assert.isEqual(this.vc.views, this.vc.getVcFactory());
+    }
+    builtVcGetsConnectToApiHandler() {
+        test_utils_1.assert.isTruthy(this.vc.constructorOptions.connectToApi);
+    }
+    canMixinControllers() {
+        this.factory.mixinControllers({
+            test2: TestViewController,
+        });
+        const vc = this.factory.Controller('test2', {});
+        test_utils_1.assert.isTruthy(vc);
+        const vc2 = this.factory.Controller('test', {});
+        test_utils_1.assert.isTruthy(vc2);
+    }
+    controllersGetIdsSet() {
+        //@ts-ignore
+        test_utils_1.assert.isEqual(this.vc.id, 'test');
+    }
+    viewControllerGetTypesed() {
+        const vc = this.factory.Controller('test', {});
+        test_utils_1.assert.isExactType(true);
+    }
+    skillViewControllerGetTyped() {
+        const vc = this.factory.Controller('testSkillView', {});
+        test_utils_1.assert.isExactType(true);
+    }
+    throwsIfViewControllerSetsIdProperty() {
+        this.factory.mixinControllers({
+            test3: TestViewControllerWithId,
+        });
+        //@ts-ignore
+        const err = test_utils_1.assert.doesThrow(() => this.factory.Controller('test3'));
+        test_utils_2.errorAssert.assertError(err, 'INVALID_SKILL_VIEW_CONTROLLER');
+    }
+    controllerFactoryMethod() {
+        const vc = this.Controller('testSkillView', {});
+        let wasHit = false;
+        //@ts-ignore
+        vc.views.Controller = () => {
+            wasHit = true;
+        };
+        vc.Controller('card', {});
+        test_utils_1.assert.isTrue(wasHit);
+    }
+    canSetVoteHandler() {
+        const handler = () => { };
+        //@ts-ignore
+        this.factory.setVoteHandler(handler);
+        const vc = this.factory.Controller('testSkillView', {});
+        //@ts-ignore
+        test_utils_1.assert.isEqual(vc.voteHandler, handler);
+    }
+    canGetVcClass(id, Class) {
+        const Actual = this.factory.getController(id);
+        test_utils_1.assert.isEqual(Actual, Class);
+    }
+    async datesIsDateUtil() {
+        this.assertDatesInContructorOptions(calendar_utils_1.dateUtil);
+        this.assertDatesPropEquals(calendar_utils_1.dateUtil);
+    }
+    async canPassDateUtilToFactory() {
+        const dates = {};
+        this.factory = this.Factory({
+            dates,
+        });
+        this.vc = this.factory.Controller('test', {});
+        this.assertDatesInContructorOptions(dates);
+        this.assertDatesPropEquals(dates);
+    }
+    async passesThroughMapsUtil() {
+        const maps = {
+            openNavigation(_options) { },
+        };
+        this.factory = this.Factory({
+            maps,
+        });
+        const vc = this.factory.Controller('test', {});
+        test_utils_1.assert.isEqual(vc.getMaps(), maps);
+    }
+    async canSetDatesLater() {
+        const d = (0, test_utils_2.generateId)();
+        this.factory.setDates(d);
+        //@ts-ignore
+        test_utils_1.assert.isEqual(this.factory.dates, d);
+    }
+    assertDatesPropEquals(expected) {
+        test_utils_1.assert.isEqual(this.vc.getDates(), expected);
+    }
+    assertDatesInContructorOptions(expected) {
+        test_utils_1.assert.isEqual(this.vc.constructorOptions.dates, expected);
+    }
+};
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "canCreateBuildingViewControllers", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "throwsWithoutSettingConnectToApiHandler", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "throwsWithInvalidName", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "hasController", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "doesNotHaveController", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "getsVcFactoryInConstructorOptions", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "canGetVcFactory", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "builtVcGetsConnectToApiHandler", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "canMixinControllers", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "controllersGetIdsSet", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "viewControllerGetTypesed", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "skillViewControllerGetTyped", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "throwsIfViewControllerSetsIdProperty", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "controllerFactoryMethod", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "canSetVoteHandler", null);
+__decorate([
+    (0, test_utils_1.test)('can get vc class 1', 'test', TestViewController),
+    (0, test_utils_1.test)('can get vc class 2', 'testSkillView', TestSkillViewController)
+], BuildingViewControllersTest.prototype, "canGetVcClass", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "datesIsDateUtil", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "canPassDateUtilToFactory", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "passesThroughMapsUtil", null);
+__decorate([
+    (0, test_utils_1.test)()
+], BuildingViewControllersTest.prototype, "canSetDatesLater", null);
+BuildingViewControllersTest = __decorate([
+    (0, test_utils_1.suite)()
+], BuildingViewControllersTest);
+exports.default = BuildingViewControllersTest;

package/build/__tests__/behavioral/DestroyingVcs.test.d.ts

@@ -0,0 +1,39 @@
+import { AbstractSkillViewController, ViewControllerOptions } from '../..';
+import AbstractViewControllerTest from '../../tests/AbstractViewControllerTest';
+import CardViewController from '../../viewControllers/card/Card.vc';
+declare class DestroyViewController extends AbstractSkillViewController {
+    cardVc: CardViewController;
+    cardVc2: CardViewController;
+    constructor(options: ViewControllerOptions);
+    render(): {
+        layouts: never[];
+    };
+}
+declare class NoChildrenViewController extends AbstractSkillViewController {
+    constructor(options: ViewControllerOptions);
+    render(): {
+        layouts: never[];
+    };
+}
+declare module '../../types/heartwood.types' {
+    interface ViewControllerMap {
+        destroy: DestroyViewController;
+        noChildren: NoChildrenViewController;
+    }
+}
+export default class DestroyingVcsTest extends AbstractViewControllerTest {
+    protected controllerMap: {
+        destroy: typeof DestroyViewController;
+        noChildren: typeof NoChildrenViewController;
+    };
+    protected beforeEach(): Promise<void>;
+    protected factoryHasDestroy(method: Method): Promise<void>;
+    protected destroyCallsDestroyOnChildren(method: Method): Promise<void>;
+    protected destroyWithNoChildren(method: Method): Promise<void>;
+    protected destroysChildEvenWithoutLocalReference(): Promise<void>;
+    protected callingDestroyTwiceThrows(): Promise<void>;
+    protected doesNotDoubleDestroyChildren(): Promise<void>;
+    private Vc;
+}
+type Method = 'Controller' | 'App';
+export {};