@sprucelabs/spruce-calendar-components 22.4.6 → 22.4.9

package/build/.spruce/schemas/schemas.types.d.ts

@@ -2046,41 +2046,41 @@ declare module '@sprucelabs/spruce-core-schemas/build/.spruce/schemas/core.schem
         }
     }
     namespace SpruceSchemas.Calendar.v2021_05_19 {
-        interface GetCalendarEventEmitTarget {
-            'locationId': string;
-            'calendarEventId': string;
+        interface GetCalendarEmitTarget {
+            'organizationId': string;
+            'slug': string;
         }
-        interface GetCalendarEventEmitTargetSchema extends SpruceSchema.Schema {
-            id: 'getCalendarEventEmitTarget';
+        interface GetCalendarEmitTargetSchema extends SpruceSchema.Schema {
+            id: 'getCalendarEmitTarget';
             version: 'v2021_05_19';
             namespace: 'Calendar';
             name: '';
             fields: {
                 /** . */
-                'locationId': {
+                'organizationId': {
                     type: 'id';
                     isRequired: true;
                     options: undefined;
                 };
                 /** . */
-                'calendarEventId': {
+                'slug': {
                     type: 'id';
                     isRequired: true;
                     options: undefined;
                 };
             };
         }
-        interface GetCalendarEventEmitTargetEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetCalendarEventEmitTargetSchema> {
+        interface GetCalendarEmitTargetEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetCalendarEmitTargetSchema> {
         }
     }
     namespace SpruceSchemas.Calendar.v2021_05_19 {
-        interface GetCalendarEventEmitTargetAndPayload {
+        interface GetCalendarEmitTargetAndPayload {
             /** Source. */
             'source'?: SpruceSchemas.SpruceEventUtils.v2021_09_13.EventSource | undefined | null;
-            'target': SpruceSchemas.Calendar.v2021_05_19.GetCalendarEventEmitTarget;
+            'target': SpruceSchemas.Calendar.v2021_05_19.GetCalendarEmitTarget;
         }
-        interface GetCalendarEventEmitTargetAndPayloadSchema extends SpruceSchema.Schema {
-            id: 'getCalendarEventEmitTargetAndPayload';
+        interface GetCalendarEmitTargetAndPayloadSchema extends SpruceSchema.Schema {
+            id: 'getCalendarEmitTargetAndPayload';
             version: 'v2021_05_19';
             namespace: 'Calendar';
             name: '';
@@ -2098,73 +2098,73 @@ declare module '@sprucelabs/spruce-core-schemas/build/.spruce/schemas/core.schem
                     type: 'schema';
                     isRequired: true;
                     options: {
-                        schema: SpruceSchemas.Calendar.v2021_05_19.GetCalendarEventEmitTargetSchema;
+                        schema: SpruceSchemas.Calendar.v2021_05_19.GetCalendarEmitTargetSchema;
                     };
                 };
             };
         }
-        interface GetCalendarEventEmitTargetAndPayloadEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetCalendarEventEmitTargetAndPayloadSchema> {
+        interface GetCalendarEmitTargetAndPayloadEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetCalendarEmitTargetAndPayloadSchema> {
         }
     }
     namespace SpruceSchemas.Calendar.v2021_05_19 {
-        interface GetCalendarEventResponsePayload {
-            'calendarEvent': SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent;
+        interface GetCalendarResponsePayload {
+            'calendar': SpruceSchemas.Calendar.v2021_05_19.Calendar;
         }
-        interface GetCalendarEventResponsePayloadSchema extends SpruceSchema.Schema {
-            id: 'getCalendarEventResponsePayload';
+        interface GetCalendarResponsePayloadSchema extends SpruceSchema.Schema {
+            id: 'getCalendarResponsePayload';
             version: 'v2021_05_19';
             namespace: 'Calendar';
             name: '';
             fields: {
                 /** . */
-                'calendarEvent': {
+                'calendar': {
                     type: 'schema';
                     isRequired: true;
                     options: {
-                        schema: SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEventSchema;
+                        schema: SpruceSchemas.Calendar.v2021_05_19.CalendarSchema;
                     };
                 };
             };
         }
-        interface GetCalendarEventResponsePayloadEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetCalendarEventResponsePayloadSchema> {
+        interface GetCalendarResponsePayloadEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetCalendarResponsePayloadSchema> {
         }
     }
     namespace SpruceSchemas.Calendar.v2021_05_19 {
-        interface GetCalendarEmitTarget {
-            'organizationId': string;
-            'slug': string;
+        interface GetCalendarEventEmitTarget {
+            'locationId': string;
+            'calendarEventId': string;
         }
-        interface GetCalendarEmitTargetSchema extends SpruceSchema.Schema {
-            id: 'getCalendarEmitTarget';
+        interface GetCalendarEventEmitTargetSchema extends SpruceSchema.Schema {
+            id: 'getCalendarEventEmitTarget';
             version: 'v2021_05_19';
             namespace: 'Calendar';
             name: '';
             fields: {
                 /** . */
-                'organizationId': {
+                'locationId': {
                     type: 'id';
                     isRequired: true;
                     options: undefined;
                 };
                 /** . */
-                'slug': {
+                'calendarEventId': {
                     type: 'id';
                     isRequired: true;
                     options: undefined;
                 };
             };
         }
-        interface GetCalendarEmitTargetEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetCalendarEmitTargetSchema> {
+        interface GetCalendarEventEmitTargetEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetCalendarEventEmitTargetSchema> {
         }
     }
     namespace SpruceSchemas.Calendar.v2021_05_19 {
-        interface GetCalendarEmitTargetAndPayload {
+        interface GetCalendarEventEmitTargetAndPayload {
             /** Source. */
             'source'?: SpruceSchemas.SpruceEventUtils.v2021_09_13.EventSource | undefined | null;
-            'target': SpruceSchemas.Calendar.v2021_05_19.GetCalendarEmitTarget;
+            'target': SpruceSchemas.Calendar.v2021_05_19.GetCalendarEventEmitTarget;
         }
-        interface GetCalendarEmitTargetAndPayloadSchema extends SpruceSchema.Schema {
-            id: 'getCalendarEmitTargetAndPayload';
+        interface GetCalendarEventEmitTargetAndPayloadSchema extends SpruceSchema.Schema {
+            id: 'getCalendarEventEmitTargetAndPayload';
             version: 'v2021_05_19';
             namespace: 'Calendar';
             name: '';
@@ -2182,35 +2182,35 @@ declare module '@sprucelabs/spruce-core-schemas/build/.spruce/schemas/core.schem
                     type: 'schema';
                     isRequired: true;
                     options: {
-                        schema: SpruceSchemas.Calendar.v2021_05_19.GetCalendarEmitTargetSchema;
+                        schema: SpruceSchemas.Calendar.v2021_05_19.GetCalendarEventEmitTargetSchema;
                     };
                 };
             };
         }
-        interface GetCalendarEmitTargetAndPayloadEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetCalendarEmitTargetAndPayloadSchema> {
+        interface GetCalendarEventEmitTargetAndPayloadEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetCalendarEventEmitTargetAndPayloadSchema> {
         }
     }
     namespace SpruceSchemas.Calendar.v2021_05_19 {
-        interface GetCalendarResponsePayload {
-            'calendar': SpruceSchemas.Calendar.v2021_05_19.Calendar;
+        interface GetCalendarEventResponsePayload {
+            'calendarEvent': SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent;
         }
-        interface GetCalendarResponsePayloadSchema extends SpruceSchema.Schema {
-            id: 'getCalendarResponsePayload';
+        interface GetCalendarEventResponsePayloadSchema extends SpruceSchema.Schema {
+            id: 'getCalendarEventResponsePayload';
             version: 'v2021_05_19';
             namespace: 'Calendar';
             name: '';
             fields: {
                 /** . */
-                'calendar': {
+                'calendarEvent': {
                     type: 'schema';
                     isRequired: true;
                     options: {
-                        schema: SpruceSchemas.Calendar.v2021_05_19.CalendarSchema;
+                        schema: SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEventSchema;
                     };
                 };
             };
         }
-        interface GetCalendarResponsePayloadEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetCalendarResponsePayloadSchema> {
+        interface GetCalendarEventResponsePayloadEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetCalendarEventResponsePayloadSchema> {
         }
     }
     namespace SpruceSchemas.Calendar.v2021_05_19 {
@@ -2339,106 +2339,6 @@ declare module '@sprucelabs/spruce-core-schemas/build/.spruce/schemas/core.schem
         interface GetConflictsForTimeRangeResponsePayloadEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetConflictsForTimeRangeResponsePayloadSchema> {
         }
     }
-    namespace SpruceSchemas.Calendar.v2021_05_19 {
-        interface GetPreferencesEmitTarget {
-            'organizationId': string;
-        }
-        interface GetPreferencesEmitTargetSchema extends SpruceSchema.Schema {
-            id: 'getPreferencesEmitTarget';
-            version: 'v2021_05_19';
-            namespace: 'Calendar';
-            name: '';
-            fields: {
-                /** . */
-                'organizationId': {
-                    type: 'id';
-                    isRequired: true;
-                    options: undefined;
-                };
-            };
-        }
-        interface GetPreferencesEmitTargetEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetPreferencesEmitTargetSchema> {
-        }
-    }
-    namespace SpruceSchemas.Calendar.v2021_05_19 {
-        interface GetPreferencesEmitTargetAndPayload {
-            /** Source. */
-            'source'?: SpruceSchemas.SpruceEventUtils.v2021_09_13.EventSource | undefined | null;
-            'target': SpruceSchemas.Calendar.v2021_05_19.GetPreferencesEmitTarget;
-        }
-        interface GetPreferencesEmitTargetAndPayloadSchema extends SpruceSchema.Schema {
-            id: 'getPreferencesEmitTargetAndPayload';
-            version: 'v2021_05_19';
-            namespace: 'Calendar';
-            name: '';
-            fields: {
-                /** Source. */
-                'source': {
-                    label: 'Source';
-                    type: 'schema';
-                    options: {
-                        schema: SpruceSchemas.SpruceEventUtils.v2021_09_13.EventSourceSchema;
-                    };
-                };
-                /** . */
-                'target': {
-                    type: 'schema';
-                    isRequired: true;
-                    options: {
-                        schema: SpruceSchemas.Calendar.v2021_05_19.GetPreferencesEmitTargetSchema;
-                    };
-                };
-            };
-        }
-        interface GetPreferencesEmitTargetAndPayloadEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetPreferencesEmitTargetAndPayloadSchema> {
-        }
-    }
-    namespace SpruceSchemas.Calendar.v2021_05_19 {
-        interface GetPreferencesResponsePayload {
-            'selectedCalendarIds'?: string[] | undefined | null;
-            'visiblePeopleMode'?: ("me" | "working" | "custom") | undefined | null;
-            'visiblePeopleIds'?: string[] | undefined | null;
-        }
-        interface GetPreferencesResponsePayloadSchema extends SpruceSchema.Schema {
-            id: 'getPreferencesResponsePayload';
-            version: 'v2021_05_19';
-            namespace: 'Calendar';
-            name: '';
-            fields: {
-                /** . */
-                'selectedCalendarIds': {
-                    type: 'id';
-                    isArray: true;
-                    minArrayLength: 0;
-                    options: undefined;
-                };
-                /** . */
-                'visiblePeopleMode': {
-                    type: 'select';
-                    options: {
-                        choices: [{
-                            "value": "me";
-                            "label": "Me";
-                        }, {
-                            "value": "working";
-                            "label": "Working";
-                        }, {
-                            "value": "custom";
-                            "label": "Custom";
-                        }];
-                    };
-                };
-                /** . */
-                'visiblePeopleIds': {
-                    type: 'text';
-                    isArray: true;
-                    options: undefined;
-                };
-            };
-        }
-        interface GetPreferencesResponsePayloadEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetPreferencesResponsePayloadSchema> {
-        }
-    }
     namespace SpruceSchemas.Calendar.v2021_05_19 {
         interface GetSchedulesEmitTarget {
             'organizationId'?: string | undefined | null;
@@ -2575,6 +2475,106 @@ declare module '@sprucelabs/spruce-core-schemas/build/.spruce/schemas/core.schem
         interface GetSchedulesResponsePayloadEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetSchedulesResponsePayloadSchema> {
         }
     }
+    namespace SpruceSchemas.Calendar.v2021_05_19 {
+        interface GetPreferencesEmitTarget {
+            'organizationId': string;
+        }
+        interface GetPreferencesEmitTargetSchema extends SpruceSchema.Schema {
+            id: 'getPreferencesEmitTarget';
+            version: 'v2021_05_19';
+            namespace: 'Calendar';
+            name: '';
+            fields: {
+                /** . */
+                'organizationId': {
+                    type: 'id';
+                    isRequired: true;
+                    options: undefined;
+                };
+            };
+        }
+        interface GetPreferencesEmitTargetEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetPreferencesEmitTargetSchema> {
+        }
+    }
+    namespace SpruceSchemas.Calendar.v2021_05_19 {
+        interface GetPreferencesEmitTargetAndPayload {
+            /** Source. */
+            'source'?: SpruceSchemas.SpruceEventUtils.v2021_09_13.EventSource | undefined | null;
+            'target': SpruceSchemas.Calendar.v2021_05_19.GetPreferencesEmitTarget;
+        }
+        interface GetPreferencesEmitTargetAndPayloadSchema extends SpruceSchema.Schema {
+            id: 'getPreferencesEmitTargetAndPayload';
+            version: 'v2021_05_19';
+            namespace: 'Calendar';
+            name: '';
+            fields: {
+                /** Source. */
+                'source': {
+                    label: 'Source';
+                    type: 'schema';
+                    options: {
+                        schema: SpruceSchemas.SpruceEventUtils.v2021_09_13.EventSourceSchema;
+                    };
+                };
+                /** . */
+                'target': {
+                    type: 'schema';
+                    isRequired: true;
+                    options: {
+                        schema: SpruceSchemas.Calendar.v2021_05_19.GetPreferencesEmitTargetSchema;
+                    };
+                };
+            };
+        }
+        interface GetPreferencesEmitTargetAndPayloadEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetPreferencesEmitTargetAndPayloadSchema> {
+        }
+    }
+    namespace SpruceSchemas.Calendar.v2021_05_19 {
+        interface GetPreferencesResponsePayload {
+            'selectedCalendarIds'?: string[] | undefined | null;
+            'visiblePeopleMode'?: ("me" | "working" | "custom") | undefined | null;
+            'visiblePeopleIds'?: string[] | undefined | null;
+        }
+        interface GetPreferencesResponsePayloadSchema extends SpruceSchema.Schema {
+            id: 'getPreferencesResponsePayload';
+            version: 'v2021_05_19';
+            namespace: 'Calendar';
+            name: '';
+            fields: {
+                /** . */
+                'selectedCalendarIds': {
+                    type: 'id';
+                    isArray: true;
+                    minArrayLength: 0;
+                    options: undefined;
+                };
+                /** . */
+                'visiblePeopleMode': {
+                    type: 'select';
+                    options: {
+                        choices: [{
+                            "value": "me";
+                            "label": "Me";
+                        }, {
+                            "value": "working";
+                            "label": "Working";
+                        }, {
+                            "value": "custom";
+                            "label": "Custom";
+                        }];
+                    };
+                };
+                /** . */
+                'visiblePeopleIds': {
+                    type: 'text';
+                    isArray: true;
+                    options: undefined;
+                };
+            };
+        }
+        interface GetPreferencesResponsePayloadEntity extends SchemaEntity<SpruceSchemas.Calendar.v2021_05_19.GetPreferencesResponsePayloadSchema> {
+        }
+    }
     namespace SpruceSchemas.Calendar.v2021_05_19 {
         interface ListCalendarEventTypesEmitPayload {
             'shouldShowOnlyMine'?: boolean | undefined | null;

package/build/__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/__tests__/support/CalendarToolBeltStateMachineTestFactory.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeRemoteEventStore = void 0;
+const calendar_utils_1 = require("@sprucelabs/calendar-utils");
+const heartwood_view_controllers_1 = require("@sprucelabs/heartwood-view-controllers");
+const spruce_test_fixtures_1 = require("@sprucelabs/spruce-test-fixtures");
+const test_utils_1 = require("@sprucelabs/test-utils");
+const RemotePreferencesStore_1 = __importDefault(require("../../stores/RemotePreferencesStore"));
+const draftGenerator_1 = __importDefault(require("../../utilities/draftGenerator"));
+const Calendar_vc_1 = __importDefault(require("../../viewControllers/Calendar.vc"));
+const SpyEventManager_1 = __importDefault(require("./SpyEventManager"));
+const SpyPeopleManager_1 = __importDefault(require("./SpyPeopleManager"));
+class CalendarToolBeltStateMachineTestFactory {
+    static async StateMachine(views) {
+        const factory = views.getFactory();
+        if (!factory.hasController('calendar.calendar')) {
+            factory.mixinControllers({
+                //@ts-ignore
+                'calendar.calendar': Calendar_vc_1.default,
+            });
+        }
+        const toolBeltVc = views.Controller('toolBelt', {});
+        const event = heartwood_view_controllers_1.calendarSeeder.generateEventValues();
+        const calendarVc = views.Controller('calendar.calendar', {
+            onAddDraftEvent: () => { },
+            onEventSwapped(draft, saved) {
+                return events.silentlySwapEvent(draft.id, saved);
+            },
+        });
+        calendarVc.addEvent(event);
+        const sm = new heartwood_view_controllers_1.ToolBeltStateMachine({
+            vcFactory: views.getFactory(),
+            toolBeltVc,
+            connectToApi: async () => spruce_test_fixtures_1.fake.getClient(),
+            context: Object.assign(Object.assign({}, views.getRouter().buildLoadOptions()), { event,
+                calendarVc, cancelEvent: () => { } }),
+        });
+        const connectToApi = async () => spruce_test_fixtures_1.fake.getClient();
+        const preferences = new FakeRemotePreferences({ connectToApi });
+        const remoteEventsStore = new FakeRemoteEventStore();
+        const events = new SpyEventManager_1.default({
+            calendarVc,
+            sm,
+            dates: calendar_utils_1.dateUtil,
+            remoteVc: {
+                fetchRemoteController: async (name) => factory.getController(name),
+            },
+            askForUpdateStrategy: async () => {
+                return 'all';
+            },
+            events: remoteEventsStore,
+            preferences,
+        });
+        await events.load();
+        events.silentlyAddEvent(event);
+        const people = new SpyPeopleManager_1.default({
+            calendarVc,
+            connectToApi,
+            preferences,
+            getVisibleEvents: () => [],
+        });
+        await sm.updateContext({ events, people });
+        await sm.on('did-update-context', () => {
+            calendarVc.updateEvent(event.id, Object.assign({}, sm.getContext().event));
+        });
+        //@ts-ignore
+        return { stateMachine: sm, toolBeltVc, calendarVc, events };
+    }
+}
+exports.default = CalendarToolBeltStateMachineTestFactory;
+class FakeRemotePreferences extends RemotePreferencesStore_1.default {
+    async loadPreferences() { }
+    async save() { }
+}
+class FakeRemoteEventStore {
+    async load(_options) { }
+    async persist(event) {
+        const e = Object.assign(Object.assign({ dateCreated: new Date().getTime() }, heartwood_view_controllers_1.calendarSeeder.generateEventValues()), event);
+        if (draftGenerator_1.default.isDraftId(e.id)) {
+            e.id = (0, test_utils_1.generateId)();
+        }
+        this.lastPersistedEvent = e;
+        return e;
+    }
+    setCalendarId(_id) { }
+    clearCalendarId() { }
+    getCalendarId() {
+        return undefined;
+    }
+    async waitForPendingSaves() { }
+    async cancelEvent(_id) { }
+    async getSchedules(_options) {
+        return [];
+    }
+    async getEventTypes() {
+        return [];
+    }
+    async getCalendars() {
+        return [];
+    }
+}
+exports.FakeRemoteEventStore = FakeRemoteEventStore;

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

@@ -0,0 +1,40 @@
+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>;
+    constructor(options: SpyEventManagerOptions);
+    getRemoteEventsStore(): SpyRemoteEventStore;
+    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?: "active" | "blocked" | "draft" | "tentative" | "upcoming" | "unavailable" | "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/__tests__/support/SpyEventManager.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CalendarEventManager_1 = __importDefault(require("../../utilities/CalendarEventManager"));
+class SpyEventManager extends CalendarEventManager_1.default {
+    constructor(options) {
+        super(options);
+    }
+    getRemoteEventsStore() {
+        return this.events;
+    }
+    getPreferences() {
+        return this.prefs;
+    }
+    silentlySetAllEvents(events) {
+        this.allEvents = events;
+    }
+    silentlyMixinEvents(events) {
+        this.allEvents = [...this.allEvents, ...events];
+    }
+    silentlyAddEvent(event) {
+        this.allEvents.push(event);
+    }
+    async updateEventInContext(updates) {
+        return super.updateEventInContext(updates);
+    }
+}
+exports.default = SpyEventManager;

package/build/__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/__tests__/support/SpyPeopleManager.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CalendarPeopleManager_1 = __importDefault(require("../../utilities/CalendarPeopleManager"));
+class SpyPeopleManager extends CalendarPeopleManager_1.default {
+    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();
+    }
+    async setVisiblePeopleIds(ids, options) {
+        return super.setVisiblePeopleIds(ids, options);
+    }
+}
+exports.default = SpyPeopleManager;