@sprucelabs/spruce-calendar-components 21.0.2 → 21.0.5

package/build/toolBelt/states/PrerequisitesToolBeltState.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrerequisitesToolBeltState = void 0;
+const makeEventTyped_1 = __importDefault(require("./makeEventTyped"));
+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;
+    }
+    async load(stateMachine) {
+        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 = await this.listCalendars();
+        }
+        if (this.calendars.length === 1) {
+            await this.handleSelectCalendar(this.calendars[0]);
+            return;
+        }
+        this.setupCalendarSelectCard(this.calendars);
+        await 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);
+    }
+    async handleSelectCalendar(calendar) {
+        var _a, _b, _c, _d;
+        (_a = this.calendarSelectCardVc) === null || _a === void 0 ? void 0 : _a.setIsBusy(true);
+        this.calendar = calendar;
+        await ((_b = this.selectCalendarHandler) === null || _b === void 0 ? void 0 : _b.call(this, calendar));
+        const client = await this.connectToApi();
+        let [{ calendarEventTypes }] = await 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) {
+            await this.handleSelectType(calendarEventTypes[0]);
+        }
+        else {
+            await this.updateEventInContext();
+            await this.setupTypeSelectCard(calendarEventTypes);
+        }
+        (_d = this.calendarSelectCardVc) === null || _d === void 0 ? void 0 : _d.setIsBusy(false);
+    }
+    async setupTypeSelectCard(types) {
+        var _a, _b, _c, _d, _e, _f;
+        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 = await 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);
+    }
+    async renderTypeButtonsSection(calendarEventTypes) {
+        const section = {
+            buttons: calendarEventTypes.map((t) => ({
+                id: t.id,
+                label: t.name,
+                onClick: () => this.handleSelectType(t),
+            })),
+        };
+        return section;
+    }
+    async handleSelectType(type) {
+        var _a, _b, _c;
+        (_a = this.typeSelectCardVc) === null || _a === void 0 ? void 0 : _a.setIsBusy(true);
+        const { event } = this.sm.getContext();
+        const updated = (0, makeEventTyped_1.default)(event, type);
+        await this.updateEventInContext({
+            eventTypeSlug: type.slug,
+            timeBlocks: updated.timeBlocks,
+        });
+        await ((_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);
+    }
+    async updateEventInContext(updates) {
+        var _a;
+        const { event } = this.sm.getContext();
+        if (event) {
+            await 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,
+            },
+        });
+    }
+    async listCalendars() {
+        const org = await this.sm.getContext().scope.getCurrentOrganization();
+        const client = await this.connectToApi();
+        const [{ calendars }] = await client.emitAndFlattenResponses('calendar.list-calendars::v2021_05_19', {
+            target: {
+                organizationId: org === null || org === void 0 ? void 0 : org.id,
+            },
+        });
+        return calendars;
+    }
+    async connectToApi() {
+        return await this.sm.connectToApi();
+    }
+}
+exports.PrerequisitesToolBeltState = PrerequisitesToolBeltState;

package/build/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/toolBelt/states/RootToolBeltState.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RootToolBeltState = void 0;
+const calendar_utils_1 = require("@sprucelabs/calendar-utils");
+const schema_1 = require("@sprucelabs/schema");
+class RootToolBeltState {
+    constructor(options) {
+        this.id = 'root';
+        const { people, events } = (0, schema_1.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,
+        });
+    }
+    async load(stateMachine) {
+        this.sm = stateMachine;
+        this.toolBeltVc = stateMachine.getToolBeltVc();
+        this.resetToolBelt();
+        this.dateSelectVc = this.sm.Controller('calendar.date-select-card', {
+            onSelectDate: (date) => this.handleSelectDate(date),
+            startDate: calendar_utils_1.dateUtil.getStartOfDay(new Date().getTime()),
+            selectedDate: this.lastSelectedDate,
+        });
+        this.toolBeltVc.addTool({
+            id: 'date-selection',
+            lineIcon: 'calendar',
+            card: this.dateSelectVc.render(),
+        });
+        await 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());
+    }
+    async optionallyAddPeopleCard(scope) {
+        var _a, _b;
+        const location = await 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(),
+            });
+            await 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,
+        });
+    }
+}
+exports.RootToolBeltState = RootToolBeltState;

package/build/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/toolBelt/states/makeEventTyped.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const draftGenerator_1 = __importDefault(require("../../utilities/draftGenerator"));
+function makeEventTyped(event, type) {
+    var _a;
+    const { timeBlocks } = event;
+    timeBlocks[0].title = draftGenerator_1.default.generateTitle(type.name);
+    timeBlocks[0].leftIcons = [{ icon: (_a = type.lineIcon) !== null && _a !== void 0 ? _a : 'coffee', hint: null }];
+    return event;
+}
+exports.default = makeEventTyped;

package/build/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';
@@ -8,6 +9,7 @@ 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;
@@ -48,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/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 {};