@sprucelabs/spruce-calendar-components 21.0.3 → 21.1.0

package/build/esm/toolBelt/states/RootToolBeltState.d.ts

@@ -0,0 +1,37 @@
+import { SpruceSchemas, ToolBeltState } from '@sprucelabs/heartwood-view-controllers';
+import { CalendarToolBeltStateMachine } from '../../types/calendar.types';
+import { CalendarEventManager } from '../../utilities/CalendarEventManager';
+import CalendarPeopleManager from '../../utilities/CalendarPeopleManager';
+import CalendarSelectCardViewController from '../../viewControllers/CalendarSelectTool.vc';
+import DateSelectCardViewController from '../../viewControllers/DateSelectCard.vc';
+import PersonSelectToolViewController from '../../viewControllers/PersonSelectTool.vc';
+export declare class RootToolBeltState implements ToolBeltState {
+    readonly id = "root";
+    private calendarSelectCardVc?;
+    private toolBeltVc;
+    private personSelectVc;
+    private sm;
+    private scopeSelectionTool?;
+    private dateSelectVc;
+    private lastSelectedDate?;
+    private people;
+    private events;
+    constructor(options: {
+        people: CalendarPeopleManager;
+        events: CalendarEventManager;
+    });
+    getCalendarSelectCardVc(): CalendarSelectCardViewController | undefined;
+    private CalendarSelectVc;
+    load(stateMachine: CalendarToolBeltStateMachine): Promise<void>;
+    private optionallyClearStickyTool;
+    private handleSelectDate;
+    private resetToolBelt;
+    private optionallyDropInScopeSelectionTool;
+    private setupCalendarSelectVc;
+    private optionallyAddPeopleCard;
+    getPersonSelectCardVc(): PersonSelectToolViewController;
+    getDateSelectVc(): DateSelectCardViewController;
+    getSelectedDate(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarSelectedDate;
+    setSelectedDate(year: number, month: number, day: number): void;
+    private PersonSelectVc;
+}

package/build/esm/toolBelt/states/RootToolBeltState.js

@@ -0,0 +1,122 @@
+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';
+export class RootToolBeltState {
+    constructor(options) {
+        this.id = 'root';
+        const { people, events } = assertOptions(options, ['people', 'events']);
+        this.people = people;
+        this.events = events;
+    }
+    getCalendarSelectCardVc() {
+        return this.calendarSelectCardVc;
+    }
+    CalendarSelectVc() {
+        var _a;
+        return (_a = this.sm) === null || _a === void 0 ? void 0 : _a.Controller('calendar.calendar-select-tool', {
+            events: this.events,
+        });
+    }
+    load(stateMachine) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.sm = stateMachine;
+            this.toolBeltVc = stateMachine.getToolBeltVc();
+            this.resetToolBelt();
+            this.dateSelectVc = this.sm.Controller('calendar.date-select-card', {
+                onSelectDate: (date) => this.handleSelectDate(date),
+                startDate: dateUtil.getStartOfDay(new Date().getTime()),
+                selectedDate: this.lastSelectedDate,
+            });
+            this.toolBeltVc.addTool({
+                id: 'date-selection',
+                lineIcon: 'calendar',
+                card: this.dateSelectVc.render(),
+            });
+            yield Promise.all([
+                this.setupCalendarSelectVc(stateMachine),
+                this.optionallyAddPeopleCard(stateMachine.getContext().scope),
+            ]);
+            this.optionallyDropInScopeSelectionTool();
+            this.optionallyClearStickyTool();
+        });
+    }
+    optionallyClearStickyTool() {
+        if (this.toolBeltVc.getStickyTools().bottom) {
+            this.toolBeltVc.removeStickyTool('bottom');
+        }
+    }
+    handleSelectDate(date) {
+        const { calendarVc } = this.sm.getContext();
+        calendarVc.setStartDate(date);
+    }
+    resetToolBelt() {
+        var _a;
+        if (!this.scopeSelectionTool) {
+            this.scopeSelectionTool = (_a = this.toolBeltVc) === null || _a === void 0 ? void 0 : _a.getTool('scope-selection');
+        }
+        this.toolBeltVc.clearTools();
+    }
+    optionallyDropInScopeSelectionTool() {
+        var _a;
+        if (this.scopeSelectionTool) {
+            (_a = this.toolBeltVc) === null || _a === void 0 ? void 0 : _a.addTool(this.scopeSelectionTool);
+        }
+    }
+    setupCalendarSelectVc(stateMachine) {
+        var _a, _b, _c;
+        this.calendarSelectCardVc = this.CalendarSelectVc();
+        (_a = this.toolBeltVc) === null || _a === void 0 ? void 0 : _a.addTool({
+            lineIcon: 'calendar',
+            id: 'calendars',
+            card: (_b = this.calendarSelectCardVc) === null || _b === void 0 ? void 0 : _b.render(),
+        });
+        return (_c = this.calendarSelectCardVc) === null || _c === void 0 ? void 0 : _c.load(stateMachine.getContext());
+    }
+    optionallyAddPeopleCard(scope) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const location = yield scope.getCurrentLocation();
+            if (location && !((_a = this.toolBeltVc) === null || _a === void 0 ? void 0 : _a.getTool('people'))) {
+                this.personSelectVc = this.PersonSelectVc();
+                (_b = this.toolBeltVc) === null || _b === void 0 ? void 0 : _b.addTool({
+                    lineIcon: 'user',
+                    id: 'people',
+                    card: this.personSelectVc.render(),
+                });
+                yield this.personSelectVc.load();
+            }
+        });
+    }
+    getPersonSelectCardVc() {
+        return this.personSelectVc;
+    }
+    getDateSelectVc() {
+        return this.dateSelectVc;
+    }
+    getSelectedDate() {
+        return this.dateSelectVc.getSelectedDate();
+    }
+    setSelectedDate(year, month, day) {
+        var _a;
+        this.lastSelectedDate = {
+            year,
+            month,
+            day,
+        };
+        (_a = this.dateSelectVc) === null || _a === void 0 ? void 0 : _a.setSelectedDate(year, month, day);
+    }
+    PersonSelectVc() {
+        var _a;
+        return (_a = this.sm) === null || _a === void 0 ? void 0 : _a.Controller('calendar.person-select-tool', {
+            people: this.people,
+        });
+    }
+}

package/build/esm/toolBelt/states/makeEventTyped.d.ts

@@ -0,0 +1,2 @@
+import { SpruceSchemas } from '@sprucelabs/heartwood-view-controllers';
+export default function makeEventTyped(event: SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent, type: SpruceSchemas.Calendar.v2021_05_19.CalendarEventType): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent;

package/build/esm/toolBelt/states/makeEventTyped.js

@@ -0,0 +1,8 @@
+import draftEventGenerator from '../../utilities/draftGenerator.js';
+export default function makeEventTyped(event, type) {
+    var _a;
+    const { timeBlocks } = event;
+    timeBlocks[0].title = draftEventGenerator.generateTitle(type.name);
+    timeBlocks[0].leftIcons = [{ icon: (_a = type.lineIcon) !== null && _a !== void 0 ? _a : 'coffee', hint: null }];
+    return event;
+}

package/build/esm/types/calendar.types.d.ts

@@ -1,6 +1,7 @@
 import { AbstractViewController, LineIcon, SkillViewControllerLoadOptions, ToolBeltState, ToolBeltStateMachine } from '@sprucelabs/heartwood-view-controllers';
 import { SpruceSchemas } from '@sprucelabs/mercury-types';
 import { EventTarget } from '@sprucelabs/spruce-event-utils';
+import { UpdateRepeatingStrategy } from '../constants';
 import { CalendarEventManager } from '../utilities/CalendarEventManager';
 import CalendarPeopleManager from '../utilities/CalendarPeopleManager';
 import CalendarViewController from '../viewControllers/Calendar.vc';
@@ -49,6 +50,7 @@ export declare type GetCalendarToolBeltContextHandler = () => CalendarToolBeltCo
 export declare type GetPersonFromEventHandler = () => Promise<Person | null>;
 export declare type GetHasPendingContextChangesHandler = () => boolean;
 export declare type CancelEventHandler = (eventId: string) => boolean | Promise<boolean | void> | void;
+export declare type UpdateRepeatingStrategyWithCancel = UpdateRepeatingStrategy | 'cancel';
 export interface CalendarToolOptions {
     updateContext: UpdateCalendarToolBeltContextHandler;
     getContext: GetCalendarToolBeltContextHandler;

package/build/esm/utilities/CalendarEventManager.d.ts

@@ -0,0 +1,73 @@
+import { DateUtils } from '@sprucelabs/calendar-utils';
+import { CalendarEvent } from '@sprucelabs/heartwood-view-controllers';
+import { RemoteViewControllerFactory } from '@sprucelabs/spruce-heartwood-utils';
+import RemoteEventStore from '../stores/RemoteEventStore';
+import RemotePreferencesStore from '../stores/RemotePreferencesStore';
+import { CalendarToolBeltStateMachine, UpdateEvent, UpdateRepeatingStrategyWithCancel } from '../types/calendar.types';
+import CalendarViewController from '../viewControllers/Calendar.vc';
+export declare class CalendarEventManager {
+    private calendarVc;
+    protected allEvents: CalendarEvent[];
+    private inclusiveCalendarIds;
+    protected events: RemoteEventStore;
+    private eventTypes?;
+    private remoteVc;
+    private hasVcForEventTypeBeenLoaded;
+    private sm;
+    private shouldIgnoreNextContextUpdate;
+    private askForUpdateStrategy;
+    private dateToUpdate?;
+    private shouldUpdateAllEventsGoingForward?;
+    private dates;
+    protected prefs: RemotePreferencesStore;
+    private calendars;
+    private shouldUpdateContextOnNextSave;
+    protected get calendarIds(): string[];
+    protected get visibleCalendarIds(): string[];
+    constructor(options: CalendarEventManagerOptions);
+    replaceEventsInRange(events: CalendarEvent[], startMs: number, endMs: number): void;
+    private refreshShifts;
+    private isCalendarSelected;
+    private doesCalenderExist;
+    getAllEvents(): CalendarEvent[];
+    getCalendars(): import("@sprucelabs/calendar-utils").SpruceSchemas.Calendar.v2021_05_19.Calendar[];
+    addDraftEvent(event: CalendarEvent): Promise<void>;
+    silentlySwapEvent(oldId: string, event: CalendarEvent): Promise<void>;
+    handleDropEvent(id: string, updates: Partial<CalendarEvent>): Promise<boolean>;
+    reset(): Promise<void>;
+    restoreEventToDraftOnStateLoadError(): Promise<void>;
+    getVisibleCalendarIds(): string[];
+    removeEvent(id: string): Promise<void>;
+    makeCalendarVisible(calendarId: string): Promise<void>;
+    makeCalendarHidden(calendarId: string): Promise<void>;
+    updateEvent(id: string, updates: Partial<CalendarEvent> & {
+        dateToUpdate?: number;
+        shouldUpdateAllEventsGoingForward?: boolean;
+    }): void;
+    loadEvents(startDate: number, endDate: number, peopleIds: string[]): Promise<void>;
+    setCalendarVisibility(calendarId: string, shouldBeVisible: boolean): Promise<void>;
+    setupVcForEventType(vcId: string, typeSlug: string): Promise<void>;
+    private assertValidCalendarId;
+    private updateEventInContext;
+    private setEventInContext;
+    selectEvent(eventId: string): Promise<void>;
+    load(): Promise<void>;
+    getEvent(id: string): CalendarEvent;
+    private loadCalendars;
+    private handleWillUpdateContext;
+    private handleDidUpdateContext;
+    private saveEvent;
+    optionallyAskForUpdateRepeatingStrategy(event: UpdateEvent): Promise<boolean>;
+}
+export declare type EventManagerCalendarVc = Pick<CalendarViewController, 'replaceEventsInRange' | 'mixinEvents' | 'removeEvent' | 'addEvent' | 'hasEvent' | 'updateEvent' | 'setShifts' | 'getShifts' | 'getEvent' | 'getPeople' | 'setControllerForEventType' | 'setRemoteStore' | 'getSelectedEvent' | 'selectEvent'>;
+declare type EventManagerRemoteViewControllerFactory = Pick<RemoteViewControllerFactory, 'fetchRemoteController'>;
+export interface CalendarEventManagerOptions {
+    calendarVc: EventManagerCalendarVc;
+    events: RemoteEventStore;
+    remoteVc: EventManagerRemoteViewControllerFactory;
+    sm: CalendarToolBeltStateMachine;
+    dates: DateUtils;
+    preferences: RemotePreferencesStore;
+    askForUpdateStrategy: (event: UpdateEvent) => Promise<UpdateRepeatingStrategyWithCancel>;
+}
+export {};

package/build/esm/utilities/CalendarEventManager.js

@@ -0,0 +1,331 @@
+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 { calendarEventSchema, } from '@sprucelabs/heartwood-view-controllers';
+import { assertOptions, normalizeSchemaValues } from '@sprucelabs/schema';
+import SpruceError from '../errors/SpruceError.js';
+import calendarShiftGenerator from './calendarShiftGenerator.js';
+import draftEventGenerator from './draftGenerator.js';
+export class CalendarEventManager {
+    constructor(options) {
+        this.allEvents = [];
+        this.inclusiveCalendarIds = [];
+        this.hasVcForEventTypeBeenLoaded = {};
+        this.shouldIgnoreNextContextUpdate = false;
+        this.calendars = [];
+        this.shouldUpdateContextOnNextSave = true;
+        const { calendarVc, events, remoteVc, sm, askForUpdateStrategy, dates, preferences, } = assertOptions(options, [
+            'calendarVc',
+            'events',
+            'remoteVc',
+            'sm',
+            'askForUpdateStrategy',
+            'dates',
+            'preferences',
+        ]);
+        this.calendarVc = calendarVc;
+        this.events = events;
+        this.remoteVc = remoteVc;
+        this.sm = sm;
+        this.prefs = preferences;
+        this.dates = dates;
+        this.askForUpdateStrategy = askForUpdateStrategy;
+        this.calendarVc.setRemoteStore(this.events);
+    }
+    get calendarIds() {
+        return this.calendars.map((c) => c.id);
+    }
+    get visibleCalendarIds() {
+        var _a;
+        return (_a = this.prefs.getVisibleCalendarIds()) !== null && _a !== void 0 ? _a : this.calendars.map((c) => c.id);
+    }
+    replaceEventsInRange(events, startMs, endMs) {
+        this.calendarVc.replaceEventsInRange(events.filter((e) => this.isCalendarSelected(e.calendarId)), startMs, endMs);
+        this.allEvents = this.allEvents.filter((e) => events.findIndex((event) => event.id === e.id) === -1 &&
+            !(e.startDateTimeMs >= startMs && e.startDateTimeMs <= endMs));
+        this.allEvents.push(...events);
+        this.refreshShifts();
+    }
+    refreshShifts() {
+        const inclusiveEvents = this.allEvents.filter((e) => this.inclusiveCalendarIds.indexOf(e.calendarId) > -1);
+        const shifts = calendarShiftGenerator.generateFromEvents(inclusiveEvents);
+        this.calendarVc.setShifts([...shifts]);
+    }
+    isCalendarSelected(calendarId) {
+        return this.visibleCalendarIds.indexOf(calendarId) > -1;
+    }
+    doesCalenderExist(calendarId) {
+        return this.calendars.findIndex((c) => c.id === calendarId) > -1;
+    }
+    getAllEvents() {
+        return this.allEvents;
+    }
+    getCalendars() {
+        return this.calendars;
+    }
+    addDraftEvent(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.calendarVc.selectEvent(event.id);
+            this.allEvents.push(event);
+            yield this.updateEventInContext(event);
+        });
+    }
+    silentlySwapEvent(oldId, event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const events = this.getAllEvents().filter((e) => e.id !== oldId);
+            this.allEvents = [...events, event];
+            yield this.updateEventInContext(event);
+        });
+    }
+    handleDropEvent(id, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const event = Object.assign(Object.assign({}, this.calendarVc.getEvent(id)), updates);
+            const pass = yield this.optionallyAskForUpdateRepeatingStrategy(event);
+            if (pass) {
+                yield this.saveEvent(event);
+            }
+            return pass;
+        });
+    }
+    reset() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            void this.setEventInContext(undefined);
+            (_a = this.events) === null || _a === void 0 ? void 0 : _a.clearCalendarId();
+        });
+    }
+    restoreEventToDraftOnStateLoadError() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const updated = yield this.updateEventInContext({
+                timeBlocks: draftEventGenerator.generateTimeBlocks(),
+                calendarId: undefined,
+                eventTypeSlug: undefined,
+            });
+            this.updateEvent(updated.id, updated);
+        });
+    }
+    getVisibleCalendarIds() {
+        return this.visibleCalendarIds;
+    }
+    removeEvent(id) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.allEvents = this.allEvents.filter((e) => e.id !== id);
+            const event = this.calendarVc.getEvent(id);
+            this.calendarVc.removeEvent(id);
+            try {
+                yield this.events.cancelEvent(event.id);
+            }
+            catch (err) {
+                console.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+                this.calendarVc.addEvent(Object.assign(Object.assign({}, event), { error: err }));
+            }
+        });
+    }
+    makeCalendarVisible(calendarId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertValidCalendarId(calendarId);
+            this.calendarVc.mixinEvents(this.allEvents.filter((e) => e.calendarId === calendarId));
+            const visibleCalendarIds = [...this.visibleCalendarIds];
+            visibleCalendarIds.push(calendarId);
+            yield this.prefs.setVisibleCalendarIds(visibleCalendarIds);
+        });
+    }
+    makeCalendarHidden(calendarId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertValidCalendarId(calendarId);
+            const visibleCalendarIds = this.visibleCalendarIds.filter((id) => id !== calendarId);
+            for (const event of this.allEvents) {
+                if (event.calendarId === calendarId &&
+                    this.calendarVc.hasEvent(event.id)) {
+                    this.calendarVc.removeEvent(event.id);
+                }
+            }
+            yield this.prefs.setVisibleCalendarIds(visibleCalendarIds);
+        });
+    }
+    updateEvent(id, updates) {
+        var _a;
+        this.calendarVc.updateEvent(id, updates);
+        const idx = this.allEvents.findIndex((e) => e.id === id);
+        this.allEvents[idx] = Object.assign(Object.assign({}, this.allEvents[idx]), updates);
+        this.refreshShifts();
+        if (this.shouldUpdateContextOnNextSave &&
+            ((_a = this.sm.getContext().event) === null || _a === void 0 ? void 0 : _a.id) === id) {
+            this.shouldIgnoreNextContextUpdate = true;
+            void this.updateEventInContext(updates);
+        }
+        this.shouldUpdateContextOnNextSave = true;
+    }
+    loadEvents(startDate, endDate, peopleIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const events = yield this.events.getSchedules({
+                calendarIds: this.calendarIds,
+                startDate,
+                endDate,
+                peopleIds,
+            });
+            this.replaceEventsInRange(events, startDate, endDate);
+            if (!this.eventTypes) {
+                this.eventTypes = yield this.events.loadEventTypes();
+            }
+            yield Promise.all(events.map((e) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const type = (_a = this.eventTypes) === null || _a === void 0 ? void 0 : _a.find((t) => t.slug === e.eventTypeSlug);
+                if (type === null || type === void 0 ? void 0 : type.viewControllerId) {
+                    yield this.setupVcForEventType(type.viewControllerId, type.slug);
+                }
+            })));
+        });
+    }
+    setCalendarVisibility(calendarId, shouldBeVisible) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (shouldBeVisible) {
+                yield this.makeCalendarVisible(calendarId);
+            }
+            else {
+                yield this.makeCalendarHidden(calendarId);
+            }
+        });
+    }
+    setupVcForEventType(vcId, typeSlug) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.hasVcForEventTypeBeenLoaded[vcId]) {
+                return;
+            }
+            this.hasVcForEventTypeBeenLoaded[vcId] = true;
+            yield this.remoteVc.fetchRemoteController(vcId);
+            this.calendarVc.setControllerForEventType(typeSlug, vcId);
+        });
+    }
+    assertValidCalendarId(calendarId) {
+        if (!this.doesCalenderExist(calendarId)) {
+            throw new SpruceError({
+                code: 'CALENDAR_NOT_FOUND',
+                calendarIds: [calendarId],
+            });
+        }
+    }
+    updateEventInContext(updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { event } = this.sm.getContext();
+            const updated = Object.assign(Object.assign(Object.assign({}, event), updates), { isBusy: false });
+            yield this.setEventInContext(updated);
+            return updated;
+        });
+    }
+    setEventInContext(newEvent, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.shouldIgnoreNextContextUpdate =
+                (options === null || options === void 0 ? void 0 : options.shouldHandleDidUpdateContext) !== false;
+            yield this.sm.updateContext({
+                event: newEvent,
+            });
+        });
+    }
+    selectEvent(eventId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lastSelected = this.calendarVc.getSelectedEvent();
+            const event = this.calendarVc.getEvent(eventId);
+            this.calendarVc.selectEvent(event.id);
+            if ((lastSelected === null || lastSelected === void 0 ? void 0 : lastSelected.id) !== event.id) {
+                yield this.setEventInContext(event);
+            }
+        });
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sm.on('will-update-context', this.handleWillUpdateContext.bind(this));
+            yield this.sm.on('did-update-context', this.handleDidUpdateContext.bind(this));
+            yield this.loadCalendars();
+            this.inclusiveCalendarIds = this.calendars
+                .filter((c) => c.availableTimeSlotBehavior === 'include')
+                .map((c) => c.id);
+        });
+    }
+    getEvent(id) {
+        const event = this.allEvents.find((e) => e.id === id);
+        if (!event) {
+            throw new SpruceError({
+                code: 'EVENT_NOT_FOUND',
+                id,
+            });
+        }
+        return event;
+    }
+    loadCalendars() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.calendars = yield this.events.loadCalendars();
+        });
+    }
+    handleWillUpdateContext(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { event: originalEvent } = options.current;
+            const { event } = options.updates;
+            let pass = true;
+            if ((event === null || event === void 0 ? void 0 : event.id) &&
+                (originalEvent === null || originalEvent === void 0 ? void 0 : originalEvent.id) === (event === null || event === void 0 ? void 0 : event.id) &&
+                !this.shouldIgnoreNextContextUpdate) {
+                pass = yield this.optionallyAskForUpdateRepeatingStrategy(event);
+            }
+            return {
+                shouldAllowUpdates: pass,
+            };
+        });
+    }
+    handleDidUpdateContext() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.shouldIgnoreNextContextUpdate) {
+                this.shouldIgnoreNextContextUpdate = false;
+                return;
+            }
+            const { event } = this.sm.getContext();
+            if (event === null || event === void 0 ? void 0 : event.id) {
+                this.shouldUpdateContextOnNextSave = false;
+                yield this.saveEvent(event);
+            }
+        });
+    }
+    saveEvent(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const cleaned = normalizeSchemaValues(calendarEventSchema, Object.assign({}, event), {});
+                this.updateEvent(event.id, Object.assign(Object.assign({}, cleaned), { dateToUpdate: this.dateToUpdate, shouldUpdateAllEventsGoingForward: this.shouldUpdateAllEventsGoingForward }));
+            }
+            catch (err) {
+                console.error('Updating event in context from root failed because:\n\n', err);
+            }
+        });
+    }
+    optionallyAskForUpdateRepeatingStrategy(event) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const cleaned = normalizeSchemaValues(calendarEventSchema, event, {});
+            if (((_a = cleaned.totalInRepeating) !== null && _a !== void 0 ? _a : 0) > 1) {
+                let strategy = yield this.askForUpdateStrategy(cleaned);
+                if (strategy === 'cancel') {
+                    return false;
+                }
+                else if (strategy === 'only-this-one') {
+                    this.dateToUpdate = this.dates.getStartOfDay(event.startDateTimeMs);
+                    this.shouldUpdateAllEventsGoingForward = false;
+                }
+                else if (strategy === 'all-going-forward') {
+                    this.dateToUpdate = this.dates.getStartOfDay(event.startDateTimeMs);
+                    this.shouldUpdateAllEventsGoingForward = true;
+                }
+                else {
+                    this.dateToUpdate = undefined;
+                    this.shouldUpdateAllEventsGoingForward = false;
+                }
+            }
+            return true;
+        });
+    }
+}

package/build/esm/utilities/CalendarPeopleManager.d.ts

@@ -0,0 +1,56 @@
+import { MercuryClient } from '@sprucelabs/mercury-client';
+import { AbstractEventEmitter } from '@sprucelabs/mercury-event-emitter';
+import { CalendarPerson } from '../skillViewControllers/Root.svc';
+import RemotePreferencesStore from '../stores/RemotePreferencesStore';
+import { CalendarEvent } from '../types/calendar.types';
+import CalendarViewController from '../viewControllers/Calendar.vc';
+import { PersonMode } from '../viewControllers/PersonSelectTool.vc';
+export default class CalendarPeopleManager extends AbstractEventEmitter<PeopleContract> {
+    private connectToApi;
+    private prefs;
+    private client;
+    private loggedInPerson?;
+    private locationId;
+    private organizationId;
+    private team;
+    private getVisibleEvents;
+    constructor(options: PeopleManagerOptions);
+    load(options: {
+        loggedInPerson?: CalendarPerson | null;
+        locationId: string;
+        organizationId: string;
+    }): Promise<void>;
+    private loadTeam;
+    getVisiblePeople(): CalendarPerson[];
+    private teammateById;
+    getTeam(): import("@sprucelabs/mercury-types").SpruceSchemas.Spruce.v2020_07_22.Person[];
+    getLoggedInPerson(): import("@sprucelabs/mercury-types").SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarPerson | undefined;
+    protected getVisiblePeopleIds(): string[];
+    private getSavedVisiblePeopleIds;
+    getVisibilityMode(): PersonMode;
+    setVisibilityMode(mode: PersonMode): Promise<void>;
+    private setVisibilityToMe;
+    private setVisibleToWorking;
+    private getWorkingPeopleIds;
+    private getWorkingPeople;
+    protected setVisiblePeopleIds(visible: string[], options?: SetVisiblePeolpeOptions): Promise<void>;
+    setPersonVisibility(id: string, shouldBeVisible: boolean): Promise<void>;
+    private emitDidUpdate;
+}
+export interface PeopleManagerOptions {
+    connectToApi: () => Promise<MercuryClient>;
+    preferences: RemotePreferencesStore;
+    calendarVc: PeopleManagerCalendarVc;
+    getVisibleEvents: () => CalendarEvent[];
+}
+export declare type PeopleManagerCalendarVc = Pick<CalendarViewController, 'addPerson' | 'getPeople' | 'removePerson' | 'setPeople'>;
+declare const peopleContract: {
+    eventSignatures: {
+        'did-update': {};
+    };
+};
+declare type PeopleContract = typeof peopleContract;
+export interface SetVisiblePeolpeOptions {
+    shouldForceEmitDidChange?: boolean;
+}
+export {};