@sprucelabs/spruce-calendar-components 22.7.8 → 22.7.12

package/build/esm/__tests__/support/CalendarToolBeltStateMachineTestFactory.d.ts

@@ -0,0 +1,39 @@
+import { SpruceSchemas } from '@sprucelabs/calendar-utils';
+import { ToolBeltViewController } from '@sprucelabs/heartwood-view-controllers';
+import { ViewFixture } from '@sprucelabs/spruce-test-fixtures';
+import { GetScheduleOptions, RemoteEventStore } from '../../stores/RemoteEventStore';
+import { CalendarToolBeltStateMachine, UpdateEvent } from '../../types/calendar.types';
+import CalendarViewController from '../../viewControllers/Calendar.vc';
+import SpyEventManager from './SpyEventManager';
+export default class CalendarToolBeltStateMachineTestFactory {
+    static StateMachine(views: ViewFixture): Promise<{
+        stateMachine: CalendarToolBeltStateMachine;
+        toolBeltVc: ToolBeltViewController;
+        calendarVc: CalendarViewController;
+        events: SpyEventManager;
+    }>;
+}
+declare module '@sprucelabs/heartwood-view-controllers/build/types/heartwood.types' {
+    interface ViewControllerMap {
+        'calendar.calendar': CalendarViewController;
+    }
+    interface ViewControllerOptionsMap {
+        'calendar.calendar': ConstructorParameters<typeof CalendarViewController>[0];
+    }
+}
+export declare class FakeRemoteEventStore implements RemoteEventStore {
+    lastPersistedEvent?: SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent;
+    load(_options: {
+        organizationId: string;
+        locationId: string;
+    }): Promise<void>;
+    persist(event: UpdateEvent): Promise<SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent>;
+    setCalendarId(_id: string): void;
+    clearCalendarId(): void;
+    getCalendarId(): string | undefined;
+    waitForPendingSaves(): Promise<void>;
+    cancelEvent(_id: string): Promise<void>;
+    getSchedules(_options: GetScheduleOptions): Promise<SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent[]>;
+    getEventTypes(): Promise<SpruceSchemas.Calendar.v2021_05_19.CalendarEventType[]>;
+    getCalendars(): Promise<SpruceSchemas.Calendar.v2021_05_19.Calendar[]>;
+}

package/build/esm/__tests__/support/CalendarToolBeltStateMachineTestFactory.js

@@ -0,0 +1,126 @@
+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 { calendarSeeder, ToolBeltStateMachine, } from '@sprucelabs/heartwood-view-controllers';
+import { fake } from '@sprucelabs/spruce-test-fixtures';
+import { generateId } from '@sprucelabs/test-utils';
+import RemotePreferencesStore from '../../stores/RemotePreferencesStore.js';
+import draftEventGenerator from '../../utilities/draftGenerator.js';
+import CalendarViewController from '../../viewControllers/Calendar.vc.js';
+import SpyEventManager from './SpyEventManager.js';
+import SpyPeopleManager from './SpyPeopleManager.js';
+export default class CalendarToolBeltStateMachineTestFactory {
+    static StateMachine(views) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const factory = views.getFactory();
+            if (!factory.hasController('calendar.calendar')) {
+                factory.mixinControllers({
+                    //@ts-ignore
+                    'calendar.calendar': CalendarViewController,
+                });
+            }
+            const toolBeltVc = views.Controller('toolBelt', {});
+            const event = calendarSeeder.generateEventValues();
+            const calendarVc = views.Controller('calendar.calendar', {
+                onAddDraftEvent: () => { },
+                onEventSwapped(draft, saved) {
+                    return events.silentlySwapEvent(draft.id, saved);
+                },
+            });
+            calendarVc.addEvent(event);
+            const sm = new ToolBeltStateMachine({
+                vcFactory: views.getFactory(),
+                toolBeltVc,
+                connectToApi: () => __awaiter(this, void 0, void 0, function* () { return fake.getClient(); }),
+                context: Object.assign(Object.assign({}, views.getRouter().buildLoadOptions()), { event,
+                    calendarVc, cancelEvent: () => { } }),
+            });
+            const connectToApi = () => __awaiter(this, void 0, void 0, function* () { return fake.getClient(); });
+            const preferences = new FakeRemotePreferences({ connectToApi });
+            const remoteEventsStore = new FakeRemoteEventStore();
+            const events = new SpyEventManager({
+                calendarVc,
+                sm,
+                dates: dateUtil,
+                remoteVc: {
+                    fetchRemoteController: (name) => __awaiter(this, void 0, void 0, function* () { return factory.getController(name); }),
+                },
+                askForUpdateStrategy: () => __awaiter(this, void 0, void 0, function* () {
+                    return 'all';
+                }),
+                events: remoteEventsStore,
+                preferences,
+            });
+            yield events.load();
+            events.silentlyAddEvent(event);
+            const people = new SpyPeopleManager({
+                calendarVc,
+                connectToApi,
+                preferences,
+                getVisibleEvents: () => [],
+            });
+            yield sm.updateContext({ events, people });
+            yield sm.on('did-update-context', () => {
+                calendarVc.updateEvent(event.id, Object.assign({}, sm.getContext().event));
+            });
+            //@ts-ignore
+            return { stateMachine: sm, toolBeltVc, calendarVc, events };
+        });
+    }
+}
+class FakeRemotePreferences extends RemotePreferencesStore {
+    loadPreferences() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    save() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+}
+export class FakeRemoteEventStore {
+    load(_options) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    persist(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const e = Object.assign(Object.assign({ dateCreated: new Date().getTime() }, calendarSeeder.generateEventValues()), event);
+            if (draftEventGenerator.isDraftId(e.id)) {
+                e.id = generateId();
+            }
+            this.lastPersistedEvent = e;
+            return e;
+        });
+    }
+    setCalendarId(_id) { }
+    clearCalendarId() { }
+    getCalendarId() {
+        return undefined;
+    }
+    waitForPendingSaves() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    cancelEvent(_id) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    getSchedules(_options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    getEventTypes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    getCalendars() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+}

package/build/esm/__tests__/support/SpyEventManager.d.ts

@@ -0,0 +1,42 @@
+import { CalendarEvent, CalendarToolBeltContext, UpdateCalendarToolBeltContextHandler } from '../../types/calendar.types';
+import CalendarEventManager, { CalendarEventManagerOptions } from '../../utilities/CalendarEventManager';
+import SpyRemoteEventStore from './SpyRemoteEventStore';
+import SpyRemotePreferencesStore from './SpyRemotePreferencesStore';
+export default class SpyEventManager extends CalendarEventManager {
+    updateContext?: UpdateCalendarToolBeltContextHandler<CalendarToolBeltContext>;
+    getShouldIgnoreNextContextUpdate(): boolean;
+    constructor(options: SpyEventManagerOptions);
+    getRemoteEventsStore(): SpyRemoteEventStore;
+    getStateMachine(): import("../../types/calendar.types").CalendarToolBeltStateMachine<CalendarToolBeltContext>;
+    getPreferences(): SpyRemotePreferencesStore;
+    silentlySetAllEvents(events: CalendarEvent[]): void;
+    silentlyMixinEvents(events: CalendarEvent[]): void;
+    silentlyAddEvent(event: CalendarEvent): void;
+    updateEventInContext(updates: Partial<CalendarEvent>): Promise<{
+        isBusy: boolean;
+        id: string;
+        target: import("@sprucelabs/spruce-core-schemas").SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEventTarget;
+        calendarId: string;
+        eventTypeSlug?: string | null | undefined;
+        startDateTimeMs: number;
+        isResizeable?: boolean | null | undefined;
+        style?: "draft" | "tentative" | "upcoming" | "unavailable" | "blocked" | "active" | "past" | "warn" | "critical" | null | undefined;
+        groupId?: string | null | undefined;
+        timeBlocks: import("@sprucelabs/spruce-core-schemas").SpruceSchemas.CalendarUtils.v2021_05_19.EventTimeBlock[];
+        repeats?: "weekly" | "monthly" | "daily" | null | undefined;
+        daysOfWeek?: ("sun" | "mon" | "tue" | "wed" | "thur" | "fri" | "sat")[] | null | undefined;
+        daysOfMonth?: ("1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | "11" | "12" | "13" | "14" | "15" | "16" | "17" | "18" | "19" | "20" | "21" | "22" | "23" | "24" | "25" | "26" | "27" | "28" | "29" | "30" | "31")[] | null | undefined;
+        repeatsUntil?: number | null | undefined;
+        occurrences?: number | null | undefined;
+        interval?: number | null | undefined;
+        nthOccurrences?: number[] | null | undefined;
+        activeUntilDate?: number | null | undefined;
+        exclusionDates?: import("@sprucelabs/spruce-core-schemas").SpruceSchemas.CalendarUtils.v2021_05_19.EventExclusionDate[] | null | undefined;
+        nthInRepeating?: number | null | undefined;
+        totalInRepeating?: number | null | undefined;
+        error?: Error | null | undefined;
+        isSelected?: boolean | null | undefined;
+        controller?: import("@sprucelabs/heartwood-view-controllers").CalendarEventViewController | null | undefined;
+    }>;
+}
+export declare type SpyEventManagerOptions = CalendarEventManagerOptions;

package/build/esm/__tests__/support/SpyEventManager.js

@@ -0,0 +1,44 @@
+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 CalendarEventManager from '../../utilities/CalendarEventManager.js';
+export default class SpyEventManager extends CalendarEventManager {
+    constructor(options) {
+        super(options);
+    }
+    getShouldIgnoreNextContextUpdate() {
+        return this.shouldIgnoreNextContextUpdate;
+    }
+    getRemoteEventsStore() {
+        return this.events;
+    }
+    getStateMachine() {
+        return this.sm;
+    }
+    getPreferences() {
+        return this.prefs;
+    }
+    silentlySetAllEvents(events) {
+        this.allEvents = events;
+    }
+    silentlyMixinEvents(events) {
+        this.allEvents = [...this.allEvents, ...events];
+    }
+    silentlyAddEvent(event) {
+        this.allEvents.push(event);
+    }
+    updateEventInContext(updates) {
+        const _super = Object.create(null, {
+            updateEventInContext: { get: () => super.updateEventInContext }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.updateEventInContext.call(this, updates);
+        });
+    }
+}

package/build/esm/__tests__/support/SpyPeopleManager.d.ts

@@ -0,0 +1,10 @@
+import CalendarPeopleManager, { PeopleManagerOptions, SetVisiblePeolpeOptions } from '../../utilities/CalendarPeopleManager';
+import { PersonMode } from '../../viewControllers/PersonSelectTool.vc';
+export default class SpyPeopleManager extends CalendarPeopleManager {
+    visiblePeopleIds?: string[];
+    peopleVisibilityMode?: PersonMode;
+    constructor(options: PeopleManagerOptions);
+    protected getVisiblePeopleIds(): string[];
+    getVisibilityMode(): PersonMode;
+    setVisiblePeopleIds(ids: string[], options?: SetVisiblePeolpeOptions): Promise<void>;
+}

package/build/esm/__tests__/support/SpyPeopleManager.js

@@ -0,0 +1,31 @@
+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 CalendarPeopleManager from '../../utilities/CalendarPeopleManager.js';
+export default class SpyPeopleManager extends CalendarPeopleManager {
+    constructor(options) {
+        super(options);
+    }
+    getVisiblePeopleIds() {
+        var _a;
+        return (_a = this.visiblePeopleIds) !== null && _a !== void 0 ? _a : super.getVisiblePeopleIds();
+    }
+    getVisibilityMode() {
+        var _a;
+        return (_a = this.peopleVisibilityMode) !== null && _a !== void 0 ? _a : super.getVisibilityMode();
+    }
+    setVisiblePeopleIds(ids, options) {
+        const _super = Object.create(null, {
+            setVisiblePeopleIds: { get: () => super.setVisiblePeopleIds }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.setVisiblePeopleIds.call(this, ids, options);
+        });
+    }
+}

package/build/esm/__tests__/support/SpyRemoteEventStore.d.ts

@@ -0,0 +1,18 @@
+import { MercuryClient } from '@sprucelabs/mercury-client';
+import { SpruceSchemas } from '@sprucelabs/spruce-core-schemas';
+import RemoteEventStoreImpl, { RemoteEventStoreOptions } from '../../stores/RemoteEventStore';
+import { Calendar, UpdateEvent } from '../../types/calendar.types';
+export default class SpyRemoteEventStore extends RemoteEventStoreImpl {
+    private calendars?;
+    lastPersistedEvent?: SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent;
+    constructor(options: Omit<RemoteEventStoreOptions, 'connectToApi'> & {
+        calendars?: Calendar[];
+        locationId?: string;
+        organizationId?: string;
+        client: MercuryClient;
+    });
+    setOrganizationId(id: string): void;
+    cancelEvent(_id: string): Promise<void>;
+    getCalendars(): Promise<SpruceSchemas.Calendar.v2021_05_19.Calendar[] | import("@sprucelabs/schema").SchemaStaticValues<SpruceSchemas.Calendar.v2021_05_19.CalendarSchema, false, import("@sprucelabs/schema").SchemaOptionalFieldNames<SpruceSchemas.Calendar.v2021_05_19.CalendarSchema>, import("@sprucelabs/schema").StaticSchemaAllValues<SpruceSchemas.Calendar.v2021_05_19.CalendarSchema, false>>[]>;
+    persist(event: UpdateEvent): Promise<SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent>;
+}

package/build/esm/__tests__/support/SpyRemoteEventStore.js

@@ -0,0 +1,46 @@
+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 { generateId } from '@sprucelabs/test-utils';
+import RemoteEventStoreImpl from '../../stores/RemoteEventStore.js';
+export default class SpyRemoteEventStore extends RemoteEventStoreImpl {
+    constructor(options) {
+        const { calendars, client, locationId, organizationId } = options;
+        super({ connectToApi: () => __awaiter(this, void 0, void 0, function* () { return client; }) });
+        this.client = client;
+        this.calendars = calendars;
+        this.locationId = locationId !== null && locationId !== void 0 ? locationId : generateId();
+        this.organizationId = organizationId !== null && organizationId !== void 0 ? organizationId : generateId();
+    }
+    setOrganizationId(id) {
+        this.organizationId = id;
+    }
+    cancelEvent(_id) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    getCalendars() {
+        const _super = Object.create(null, {
+            getCalendars: { get: () => super.getCalendars }
+        });
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = this.calendars) !== null && _a !== void 0 ? _a : _super.getCalendars.call(this);
+        });
+    }
+    persist(event) {
+        const _super = Object.create(null, {
+            persist: { get: () => super.persist }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = yield _super.persist.call(this, event);
+            this.lastPersistedEvent = results;
+            return results;
+        });
+    }
+}

package/build/esm/__tests__/support/SpyRemotePreferencesStore.d.ts

@@ -0,0 +1,9 @@
+import { MercuryClient } from '@sprucelabs/mercury-client';
+import RemotePreferencesStore from '../../stores/RemotePreferencesStore';
+export default class SpyRemotePreferencesStore extends RemotePreferencesStore {
+    constructor(options: {
+        client: MercuryClient;
+        visibleCalendarIds?: string[];
+    });
+    protected save(): Promise<void>;
+}

package/build/esm/__tests__/support/SpyRemotePreferencesStore.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 RemotePreferencesStore from '../../stores/RemotePreferencesStore.js';
+export default class SpyRemotePreferencesStore extends RemotePreferencesStore {
+    constructor(options) {
+        const { visibleCalendarIds, client } = options;
+        super({ connectToApi: () => __awaiter(this, void 0, void 0, function* () { return client; }) });
+        this.client = client;
+        this.isLoaded = true;
+        this.visibleCalendarIds = visibleCalendarIds;
+    }
+    save() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+}

package/build/esm/__tests__/support/utilities/calendarAssert.d.ts

@@ -0,0 +1,13 @@
+import { CalendarEvent, SpruceSchemas, ViewController } from '@sprucelabs/heartwood-view-controllers';
+declare type Calendar = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Calendar;
+declare type Event = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent;
+declare const calendarAssert: {
+    rendersTotalEvents(vc: ViewController<Calendar>, expected: number): void;
+    hasEvent(vc: ViewController<Calendar>, lookup: Partial<Event>): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent;
+    eventsAreEqual(actual: Event[], expected: Event[]): void;
+    includesInEvent(events: Event[], lookup: Partial<Event>): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent;
+    eventIsDuration(event: Event, expectedDuration: number): void;
+    eventsFallOnDows(events: CalendarEvent[], expectedDows: string[]): void;
+    eventEquals(actual: Partial<CalendarEvent> | undefined | null, expected: Partial<CalendarEvent> | undefined | null): void;
+};
+export default calendarAssert;

package/build/esm/__tests__/support/utilities/calendarAssert.js

@@ -0,0 +1,88 @@
+import { dateUtil } from '@sprucelabs/calendar-utils';
+import { renderUtil, } from '@sprucelabs/heartwood-view-controllers';
+import { assert, assertUtil } from '@sprucelabs/test';
+import clone from 'just-clone';
+const calendarAssert = {
+    rendersTotalEvents(vc, expected) {
+        const model = renderUtil.render(vc);
+        assert.isLength(model.events, expected);
+    },
+    hasEvent(vc, lookup) {
+        const { events } = renderUtil.render(vc);
+        return this.includesInEvent(events, lookup);
+    },
+    eventsAreEqual(actual, expected) {
+        function sort(a, b) {
+            return a.id > b.id ? 1 : -1;
+        }
+        actual.sort(sort);
+        expected.sort(sort);
+        assert.isEqualDeep(actual, expected);
+    },
+    includesInEvent(events, lookup) {
+        const match = events.find((e) => {
+            try {
+                assert.doesInclude(e, lookup);
+                return e;
+                // eslint-disable-next-line no-empty
+            }
+            catch (_a) { }
+            return null;
+        });
+        assert.isTruthy(match, `I could not find an event that matched:\n\n${assertUtil.stringify(lookup)}`);
+        return match;
+    },
+    eventIsDuration(event, expectedDuration) {
+        const duration = event.timeBlocks.reduce((minutes, timeBlock) => {
+            minutes += timeBlock.durationMinutes;
+            return minutes;
+        }, 0);
+        assert.isEqual(duration, expectedDuration);
+    },
+    eventsFallOnDows(events, expectedDows) {
+        const remaining = [...expectedDows];
+        for (const event of events) {
+            const dow = dateUtil.getDayOfWeek(event.startDateTimeMs);
+            const idx = remaining.indexOf(dow);
+            if (idx === -1) {
+                assert.fail(`Checking days of week and got ${dow} but it wasn't in the array of expected dows.`);
+            }
+            remaining.splice(idx, 1);
+        }
+        if (remaining.length > 0) {
+            assert.fail(`Didn't find the following days of week in events:\n\n${assertUtil.stringify(remaining)}`);
+        }
+    },
+    eventEquals(actual, expected) {
+        var _a, _b, _c;
+        assert.isTruthy(actual, 'Event is missing');
+        assert.isTruthy(expected, 'Event is missing');
+        assert.isEqual(actual.startDateTimeMs, expected.startDateTimeMs, 'startDateTimeMs does not match');
+        assert.isEqual((_a = actual.isBusy) !== null && _a !== void 0 ? _a : false, (_b = expected.isBusy) !== null && _b !== void 0 ? _b : false, `isBusy does not match, needs to be '${(_c = expected.isBusy) !== null && _c !== void 0 ? _c : false}'`);
+        const cleanedActual = clone(actual);
+        const cleanedExpected = clone(expected);
+        cleanEvent(cleanedActual);
+        cleanEvent(cleanedExpected);
+        assert.isEqualDeep(cleanedActual, cleanedExpected, 'Your event did not equal what I expected!');
+    },
+};
+function cleanEvent(obj, propsToIgnore = [
+    'isSelected',
+    'source',
+    'dateCreated',
+    'isBusy',
+    'controller',
+]) {
+    for (const prop in obj) {
+        const value = obj[prop];
+        if (propsToIgnore.indexOf(prop) > -1 ||
+            value === null ||
+            typeof value === 'undefined') {
+            delete obj[prop];
+        }
+        else if (typeof value === 'object') {
+            cleanEvent(value);
+        }
+    }
+}
+export default calendarAssert;

package/build/esm/__tests__/support/utilities/calendarSkillAssert.d.ts

@@ -0,0 +1,40 @@
+import { ToolBeltState, AbstractCalendarEventViewController, ToolBeltStateMachine, SpruceSchemas } from '@sprucelabs/heartwood-view-controllers';
+import { MercuryClient } from '@sprucelabs/mercury-client';
+import { ViewFixture } from '@sprucelabs/spruce-test-fixtures';
+import AbstractCalendarEventToolBeltState from '../../../toolBelt/states/AbstractCalendarEventToolBeltState';
+export interface AssertRemoteToolsOptions {
+    client: MercuryClient;
+    state: ToolBeltState;
+    views: ViewFixture;
+}
+interface TypeWithVcId {
+    typeSlug: string;
+    vcId: string;
+}
+export declare type AssertTypeSlug = string | TypeWithVcId;
+declare const calendarSkillAssert: {
+    createdEventTypes: SpruceSchemas.Calendar.v2021_05_19.CalendarEventType[];
+    createdCalendars: SpruceSchemas.Calendar.v2021_05_19.Calendar[];
+    beforeEach(views: ViewFixture): Promise<void>;
+    createsCalendarOnInstall(calendarSlug: string, client: MercuryClient, typeSlugs?: string[]): Promise<void>;
+    createsCalendarsWithMultipleInstalls(calendarSlug: string, client: MercuryClient): Promise<void>;
+    createsEventTypesOnBoot(types: AssertTypeSlug[], client: MercuryClient, boot: () => Promise<any>): Promise<void>;
+    createsEventTypesWithMultipleBoots(types: AssertTypeSlug[], client: MercuryClient, boot: () => Promise<any>): Promise<void>;
+    isValidEventViewController(options: {
+        views: ViewFixture;
+        CalendarEventClass: typeof AbstractCalendarEventViewController;
+        ToolBeltStateClass: any;
+    }): void;
+    stateFetchesAndRendersRemoteTools(options: AssertRemoteToolsOptions): Promise<{
+        toolId: string;
+        Class: any;
+    }[]>;
+    toolBeltStateProperlyInheritsAbstractToolBeltState(stateMachine: ToolBeltStateMachine, state: AbstractCalendarEventToolBeltState): Promise<void>;
+    toolBeltStateAddsTool(options: {
+        state: AbstractCalendarEventToolBeltState;
+        toolId: string;
+        views: ViewFixture;
+        Class?: any;
+    }): Promise<SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ToolBeltTool>;
+};
+export default calendarSkillAssert;