@sprucelabs/spruce-calendar-components 20.11.1 → 21.0.4

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

@@ -0,0 +1,190 @@
+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 makeEventTyped from './makeEventTyped.js';
+export class PrerequisitesToolBeltState {
+    constructor(options) {
+        this.id = 'prerequisites';
+        this.selectCalendarHandler = options === null || options === void 0 ? void 0 : options.onSelectCalendar;
+        this.selectEventTypeHandler = options === null || options === void 0 ? void 0 : options.onSelectEventType;
+    }
+    load(stateMachine) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const toolBeltVc = stateMachine.getToolBeltVc();
+            this.toolBeltVc = toolBeltVc;
+            this.sm = stateMachine;
+            void this.toolBeltVc.renderOnce(() => {
+                this.toolBeltVc.clearTools();
+                this.toolBeltVc.clearStickyTools();
+            });
+            if (!this.calendars) {
+                this.calendars = yield this.listCalendars();
+            }
+            if (this.calendars.length === 1) {
+                yield this.handleSelectCalendar(this.calendars[0]);
+                return;
+            }
+            this.setupCalendarSelectCard(this.calendars);
+            yield this.sm.updateContext({
+                event: Object.assign(Object.assign({}, this.sm.getContext().event), { isBusy: false }),
+            });
+        });
+    }
+    destroy() { }
+    setupCalendarSelectCard(calendars) {
+        this.calendarSelectCardVc = this.SelectCalendarCardVc();
+        this.toolBeltVc.addTool({
+            id: 'calendars',
+            lineIcon: 'calendar-add',
+            card: this.calendarSelectCardVc.render(),
+        });
+        if (calendars.length > 0) {
+            this.calendarSelectCardVc.addSection({
+                buttons: calendars.map((c) => ({
+                    id: c.id,
+                    label: c.title,
+                    onClick: () => this.handleSelectCalendar(c),
+                })),
+            });
+        }
+        else {
+            this.calendarSelectCardVc.addSection({
+                text: {
+                    content: `You don't have any calendars. The only way to get one is to book an appointment or work at a place that uses Sprucebot! 🌲🤖`,
+                },
+            });
+        }
+        this.calendarSelectCardVc.setIsBusy(false);
+    }
+    handleSelectCalendar(calendar) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = this.calendarSelectCardVc) === null || _a === void 0 ? void 0 : _a.setIsBusy(true);
+            this.calendar = calendar;
+            yield ((_b = this.selectCalendarHandler) === null || _b === void 0 ? void 0 : _b.call(this, calendar));
+            const client = yield this.connectToApi();
+            let [{ calendarEventTypes }] = yield client.emitAndFlattenResponses('calendar.list-calendar-event-types::v2021_05_19');
+            const types = (_c = calendar.eventTypes) !== null && _c !== void 0 ? _c : [];
+            if (types.length > 0) {
+                calendarEventTypes = calendarEventTypes.filter((t) => types.indexOf(t.slug) > -1);
+            }
+            if (calendarEventTypes.length === 1) {
+                yield this.handleSelectType(calendarEventTypes[0]);
+            }
+            else {
+                yield this.updateEventInContext();
+                yield this.setupTypeSelectCard(calendarEventTypes);
+            }
+            (_d = this.calendarSelectCardVc) === null || _d === void 0 ? void 0 : _d.setIsBusy(false);
+        });
+    }
+    setupTypeSelectCard(types) {
+        var _a, _b, _c, _d, _e, _f;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.toolBeltVc.getTool('types')) {
+                this.typeSelectCardVc = this.TypeSelectCardVc();
+                this.toolBeltVc.addTool({
+                    id: 'types',
+                    lineIcon: 'calendar-add',
+                    card: this.typeSelectCardVc.render(),
+                });
+            }
+            (_a = this.typeSelectCardVc) === null || _a === void 0 ? void 0 : _a.setIsBusy(true);
+            (_b = this.toolBeltVc) === null || _b === void 0 ? void 0 : _b.focusTool('types');
+            const section = yield this.renderTypeButtonsSection(types);
+            if (((_c = this.typeSelectCardVc) === null || _c === void 0 ? void 0 : _c.getTotalSections()) === 0) {
+                (_d = this.typeSelectCardVc) === null || _d === void 0 ? void 0 : _d.addSection(section);
+            }
+            else {
+                (_e = this.typeSelectCardVc) === null || _e === void 0 ? void 0 : _e.setSection(0, section);
+            }
+            (_f = this.typeSelectCardVc) === null || _f === void 0 ? void 0 : _f.setIsBusy(false);
+        });
+    }
+    renderTypeButtonsSection(calendarEventTypes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const section = {
+                buttons: calendarEventTypes.map((t) => ({
+                    id: t.id,
+                    label: t.name,
+                    onClick: () => this.handleSelectType(t),
+                })),
+            };
+            return section;
+        });
+    }
+    handleSelectType(type) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = this.typeSelectCardVc) === null || _a === void 0 ? void 0 : _a.setIsBusy(true);
+            const { event } = this.sm.getContext();
+            const updated = makeEventTyped(event, type);
+            yield this.updateEventInContext({
+                eventTypeSlug: type.slug,
+                timeBlocks: updated.timeBlocks,
+            });
+            yield ((_b = this.selectEventTypeHandler) === null || _b === void 0 ? void 0 : _b.call(this, type));
+            (_c = this.typeSelectCardVc) === null || _c === void 0 ? void 0 : _c.setIsBusy(false);
+        });
+    }
+    updateEventInContext(updates) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { event } = this.sm.getContext();
+            if (event) {
+                yield this.sm.updateContext({
+                    event: Object.assign(Object.assign(Object.assign({}, event), { calendarId: (_a = this.calendar) === null || _a === void 0 ? void 0 : _a.id }), updates),
+                });
+            }
+        });
+    }
+    TypeSelectCardVc() {
+        return this.sm.Controller('card', {
+            header: {
+                title: 'What do you want to add?',
+            },
+            body: {
+                isBusy: true,
+            },
+        });
+    }
+    getCalendarSelectCardVc() {
+        return this.calendarSelectCardVc;
+    }
+    getTypeSelectCardVc() {
+        return this.typeSelectCardVc;
+    }
+    SelectCalendarCardVc() {
+        return this.sm.Controller('card', {
+            header: {
+                title: 'Which calendar?',
+            },
+            body: {
+                isBusy: true,
+            },
+        });
+    }
+    listCalendars() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const org = yield this.sm.getContext().scope.getCurrentOrganization();
+            const client = yield this.connectToApi();
+            const [{ calendars }] = yield client.emitAndFlattenResponses('calendar.list-calendars::v2021_05_19', {
+                target: {
+                    organizationId: org === null || org === void 0 ? void 0 : org.id,
+                },
+            });
+            return calendars;
+        });
+    }
+    connectToApi() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sm.connectToApi();
+        });
+    }
+}

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,11 +1,15 @@
 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';
 export interface Schedule {
     target: EventTarget;
     events: SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent[];
 }
+export declare type EventForShift = Pick<CalendarEvent, 'id' | 'timeBlocks' | 'startDateTimeMs' | 'target'>;
 export declare type DraftEvent = Pick<CalendarEvent, 'id' | 'startDateTimeMs' | 'style' | 'calendarId' | 'target' | 'timeBlocks' | 'isBusy'>;
 export declare type CalendarEvent = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent;
 export declare type UpdateEvent = SpruceSchemas.Calendar.v2021_05_19.UpdateCalendarEventEmitPayload & CalendarEvent;
@@ -17,8 +21,13 @@ export declare type SimpleCalendar = Pick<Calendar, 'id' | 'availableTimeSlotBeh
 declare type Card = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Card;
 declare type ICalendarToolBeltContext = SkillViewControllerLoadOptions & {
     event: CalendarEvent;
+    /**
+     * @deprecated use events or people to control the state of the calendar
+     */
     calendarVc: CalendarViewController;
     cancelEvent: CancelEventHandler;
+    events: CalendarEventManager;
+    people: CalendarPeopleManager;
 };
 export interface CalendarToolBeltContext extends ICalendarToolBeltContext {
 }
@@ -41,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,72 @@
+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>;
+    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 {};