@sprucelabs/spruce-calendar-components 20.11.1 → 21.0.4

package/build/skillViewControllers/Root.svc.js

@@ -0,0 +1,359 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const heartwood_view_controllers_1 = require("@sprucelabs/heartwood-view-controllers");
+const spruce_heartwood_utils_1 = require("@sprucelabs/spruce-heartwood-utils");
+const RemoteEventStore_1 = __importDefault(require("../stores/RemoteEventStore"));
+const RemotePreferencesStore_1 = __importDefault(require("../stores/RemotePreferencesStore"));
+const PrerequisitesToolBeltState_1 = require("../toolBelt/states/PrerequisitesToolBeltState");
+const RootToolBeltState_1 = require("../toolBelt/states/RootToolBeltState");
+const CalendarEventManager_1 = require("../utilities/CalendarEventManager");
+const CalendarPeopleManager_1 = __importDefault(require("../utilities/CalendarPeopleManager"));
+class RootSkillViewController extends heartwood_view_controllers_1.AbstractSkillViewController {
+    constructor(options) {
+        super(options);
+        this.getScope = () => ['employed', 'location'];
+        this.toolBeltVc = this.ToolBeltVc();
+        this.calendarVc = this.CalendarVc();
+        this.sm = this.ToolBeltStateMachine();
+        this.remoteVc = spruce_heartwood_utils_1.RemoteViewControllerFactory.Factory({
+            connectToApi: this.connectToApi.bind(this),
+            vcFactory: this.getVcFactory(),
+        });
+        this.remoteEventStore = new RemoteEventStore_1.default({
+            connectToApi: this.connectToApi.bind(this),
+        });
+        this.preferences = new RemotePreferencesStore_1.default({
+            connectToApi: this.connectToApi.bind(this),
+        });
+        this.people = new CalendarPeopleManager_1.default({
+            connectToApi: this.connectToApi.bind(this),
+            preferences: this.preferences,
+            calendarVc: this.calendarVc,
+            getVisibleEvents: this.getVisibleEvents.bind(this),
+        });
+        this.events = new CalendarEventManager_1.CalendarEventManager({
+            calendarVc: this.calendarVc,
+            events: this.remoteEventStore,
+            remoteVc: this.remoteVc,
+            dates: this.dates,
+            sm: this.sm,
+            preferences: this.preferences,
+            askForUpdateStrategy: this.askForUpdateStrategy.bind(this),
+        });
+        this.createToolBeltStates();
+    }
+    createToolBeltStates() {
+        this.toolBeltStates = {
+            root: new RootToolBeltState_1.RootToolBeltState({
+                people: this.people,
+                events: this.events,
+            }),
+            prerequisites: new PrerequisitesToolBeltState_1.PrerequisitesToolBeltState({
+                onSelectCalendar: this.handleSelectCalendar.bind(this),
+                onSelectEventType: this.handleSelectEventType.bind(this),
+            }),
+        };
+    }
+    ToolBeltStateMachine() {
+        const sm = new heartwood_view_controllers_1.ToolBeltStateMachine({
+            toolBeltVc: this.toolBeltVc,
+            vcFactory: this.getVcFactory(),
+            connectToApi: this.connectToApi.bind(this),
+            context: {
+                calendarVc: this.calendarVc,
+                cancelEvent: (eventId) => this.handleCancelEvent(eventId),
+            },
+        });
+        return sm;
+    }
+    async handleCancelEvent(eventId) {
+        const confirm = await this.confirm({
+            title: 'Cancel?',
+            message: `You wanna cancel this?`,
+        });
+        if (confirm) {
+            await this.events.removeEvent(eventId);
+        }
+    }
+    async askForUpdateStrategy(cleaned) {
+        let strategy;
+        const dlg = this.renderInDialog(Object.assign({ shouldShowCloseButton: false }, this.Controller('calendar.select-update-repeating-strategy-card', {
+            event: cleaned,
+            onSelectStrategy: async (s) => {
+                strategy = s;
+                await dlg.hide();
+            },
+        }).render()));
+        await dlg.wait();
+        return strategy;
+    }
+    async handleSelectEventType(type) {
+        var _a, _b;
+        this.selectingTypePromise = new Promise((resolve) => {
+            this.selectingTypeResolve = resolve;
+        });
+        if (type.viewControllerId) {
+            try {
+                await this.events.setupVcForEventType(type.viewControllerId, type.slug);
+                await this.transitionToStateFromDraftEvent();
+            }
+            catch (err) {
+                (_a = this.selectingTypeResolve) === null || _a === void 0 ? void 0 : _a.call(this);
+                console.error(err);
+                await this.alert({
+                    message: `I could not load what I need to add your ${type.name}! I've let the humans know and they are on the case!`,
+                });
+                await this.restoreDraftAfterStateLoadError();
+                return;
+            }
+        }
+        (_b = this.selectingTypeResolve) === null || _b === void 0 ? void 0 : _b.call(this);
+    }
+    async restoreDraftAfterStateLoadError() {
+        await this.waitUntilDoneSaving();
+        await this.sm.waitForContextUpdate();
+        void this.transitionTo(this.toolBeltStates.prerequisites);
+        await this.events.restoreEventToDraftOnStateLoadError();
+    }
+    async transitionToStateFromDraftEvent() {
+        const { event } = this.sm.getContext();
+        await this.transitionToolBeltForEvent(event.id);
+    }
+    async transitionToolBeltForEvent(eventId) {
+        var _a;
+        const vc = this.calendarVc.getEventVc(eventId);
+        const state = (_a = vc.getToolBeltState) === null || _a === void 0 ? void 0 : _a.call(vc);
+        if (state) {
+            await this.transitionTo(state);
+        }
+    }
+    async transitionTo(state) {
+        await this.sm.transitionTo(state);
+    }
+    async waitUntilDoneSaving() {
+        var _a;
+        await Promise.all([
+            (_a = this.remoteEventStore) === null || _a === void 0 ? void 0 : _a.waitForPendingSaves(),
+            this.selectingTypePromise,
+            this.transitionPromise,
+            this.loadEventsPromise,
+            this.sm.waitForContextUpdate(),
+        ]);
+    }
+    handleSelectCalendar(calendar) {
+        var _a;
+        (_a = this.remoteEventStore) === null || _a === void 0 ? void 0 : _a.setCalendarId(calendar.id);
+    }
+    getToolBeltStateMachine() {
+        return this.sm;
+    }
+    getToolBeltStateId() {
+        return this.sm.getStateId();
+    }
+    CalendarVc() {
+        return this.Controller('calendar.calendar', {
+            onClickEvent: this.handleClickEvent.bind(this),
+            onAddDraftEvent: this.handleDraftEventAdded.bind(this),
+            onRemoveDraftEvent: this.handleDraftEventRemoved.bind(this),
+            onEventSwapped: this.handleEventSwapped.bind(this),
+            onDropEvent: this.handleDropEvent.bind(this),
+            onChangeStartDate: this.handleChangeDate.bind(this),
+            onDeselectEvent: this.handleDeselectEvent.bind(this),
+        });
+    }
+    async handleChangeDate() {
+        this.makeDateSelectMatchSelectedDateFromCalendar();
+        await this.loadEvents();
+    }
+    makeDateSelectMatchSelectedDateFromCalendar() {
+        const date = this.getStartDate();
+        this.setSelectedDateInDateSelectVc(date);
+    }
+    setSelectedDateInDateSelectVc(date) {
+        const { year, month, day } = this.dates.splitDate(date);
+        this.toolBeltStates.root.setSelectedDate(year, month, day);
+    }
+    getStartDate() {
+        var _a;
+        return (_a = this.calendarVc.getStartDate()) !== null && _a !== void 0 ? _a : this.dates.date();
+    }
+    async handleDeselectEvent() {
+        if (this.calendarVc.getIsSwappingEvent()) {
+            return;
+        }
+        await this.resetToRootState();
+    }
+    async resetToRootState() {
+        await this.events.reset();
+        this.makeDateSelectMatchSelectedDateFromCalendar();
+        this.transitionPromise = this.sm.transitionTo(this.toolBeltStates.root);
+        this.toolBeltVc.close();
+        await this.transitionPromise;
+    }
+    ToolBeltVc() {
+        return this.Controller('toolBelt', {
+            shouldRenderAllToolsAtOnce: true,
+        });
+    }
+    async handleClickEvent(options) {
+        var _a, _b;
+        const { event } = options;
+        await this.events.selectEvent(event.id);
+        this.toolBeltVc.open({ shouldStayOpen: true });
+        try {
+            if (!event.eventTypeSlug) {
+                await this.transitionTo(this.toolBeltStates.prerequisites);
+            }
+            else {
+                await this.transitionToolBeltForEvent(event.id);
+            }
+        }
+        catch (err) {
+            console.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+            this.calendarVc.deselectEvent();
+            await this.alert({
+                message: (_b = err.message) !== null && _b !== void 0 ? _b : 'Shoot! I could not load that for you! Refresh and try again!!',
+            });
+        }
+    }
+    async handleDraftEventAdded(event) {
+        if (!event.eventTypeSlug) {
+            await this.events.addDraftEvent(event);
+            this.toolBeltVc.open({ shouldStayOpen: true });
+            await this.sm.transitionTo(this.toolBeltStates.prerequisites);
+        }
+    }
+    async handleEventSwapped(event) {
+        await this.events.silentlySwapEvent(this.sm.getContext().event.id, event);
+    }
+    async handleDropEvent(id, updates) {
+        return this.events.handleDropEvent(id, updates);
+    }
+    async handleDraftEventRemoved() { }
+    getPersonSelectVc() {
+        return this.toolBeltStates.root.getPersonSelectCardVc();
+    }
+    renderToolBelt() {
+        return this.toolBeltVc.render();
+    }
+    getCalendarSelectVc() {
+        return this.toolBeltStates.root.getCalendarSelectCardVc();
+    }
+    getCalendarVc() {
+        return this.calendarVc;
+    }
+    async load(options) {
+        var _a;
+        await this.sm.updateContext(Object.assign(Object.assign({}, options), { people: this.people, events: this.events }));
+        this.client = await this.connectToApi();
+        const { scope, locale, args, router } = options;
+        await locale.on('did-change-timezones', () => {
+            return this.syncOffsetWithLocale(locale);
+        });
+        const [location] = await Promise.all([
+            scope.getCurrentLocation(),
+            this.loadLoggedInPerson(),
+        ]);
+        this.organizationId = location === null || location === void 0 ? void 0 : location.organizationId;
+        this.locationId = location === null || location === void 0 ? void 0 : location.id;
+        try {
+            await this.preferences.load(this.organizationId);
+            await this.people.on('did-update', this.syncPeopleOnCalendar.bind(this));
+            await this.people.load({
+                loggedInPerson: this.person,
+                locationId: this.locationId,
+                organizationId: this.organizationId,
+            });
+            await this.remoteEventStore.load({
+                locationId: this.locationId,
+                organizationId: this.organizationId,
+            });
+            await this.events.load();
+        }
+        catch (err) {
+            await this.alert({
+                message: (_a = err.message) !== null && _a !== void 0 ? _a : 'Something catastrophic happened! We gotta get out of there!',
+            });
+            await router.redirect('heartwood.root');
+        }
+        const { startDate = this.dates.date() } = args;
+        await this.calendarVc.renderOnce(() => {
+            this.syncOffsetWithLocale(locale);
+            this.calendarVc.setStartDate(startDate);
+        });
+        await this.transitionToRoot();
+        this.setSelectedDateInDateSelectVc(startDate);
+        await this.waitUntilDoneSaving();
+    }
+    syncPeopleOnCalendar() {
+        const visiblePeople = this.people.getVisiblePeople();
+        this.calendarVc.setPeople(visiblePeople);
+    }
+    syncOffsetWithLocale(locale) {
+        const offset = locale.getTimezoneOffsetMinutes();
+        this.calendarVc.setTimezoneOffsetMs(offset * 60 * 1000);
+    }
+    async loadEvents() {
+        this.loadEventsPromise = this._loadEvents();
+        await this.loadEventsPromise;
+    }
+    async _loadEvents() {
+        var _a;
+        try {
+            if (this.events.getCalendars().length > 0) {
+                const date = this.getStartDate();
+                const startDate = this.dates.getStartOfDay(date);
+                const endDate = this.dates.getEndOfDay(date);
+                await this.events.loadEvents(startDate, endDate, this.people.getTeam().map((t) => t.id));
+                await this.people.emit('did-update');
+            }
+        }
+        catch (err) {
+            console.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+            void this.alert({
+                message: err.message,
+            });
+        }
+    }
+    async transitionToRoot() {
+        await this.sm.transitionTo(this.toolBeltStates.root);
+    }
+    async loadLoggedInPerson() {
+        const [{ auth }] = await this.client.emitAndFlattenResponses('whoami::v2020_12_25');
+        this.person = auth.person;
+    }
+    getVisibleEvents() {
+        const end = this.dates.getEndOfDay(this.calendarVc.getStartDate());
+        const start = this.dates.getStartOfDay(this.calendarVc.getStartDate());
+        const events = this.events
+            .getAllEvents()
+            .filter((e) => e.startDateTimeMs <= end && e.startDateTimeMs >= start);
+        return events;
+    }
+    render() {
+        return {
+            isFullScreen: true,
+            layouts: [
+                {
+                    cards: [
+                        {
+                            body: {
+                                sections: [
+                                    {
+                                        shouldBePadded: false,
+                                        calendar: this.calendarVc.render(),
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+}
+exports.default = RootSkillViewController;
+RootSkillViewController.id = 'root';

package/build/stores/RemotePreferencesStore.d.ts

@@ -0,0 +1,26 @@
+import { MercuryClient } from '@sprucelabs/mercury-client';
+import { PersonMode } from '../viewControllers/PersonSelectTool.vc';
+export default class RemotePreferencesStore {
+    protected isLoaded: boolean;
+    protected client: MercuryClient;
+    private organizationId;
+    private visiblePeopleMode?;
+    protected visibleCalendarIds?: string[];
+    private visiblePeopleIds?;
+    private connectToApi;
+    constructor(options: RemotePreferencesStoreOptions);
+    load(organizationId: string): Promise<void>;
+    protected loadPreferences(): Promise<void>;
+    setVisibleCalendarIds(ids: string[]): Promise<void>;
+    protected save(): Promise<void>;
+    getVisibleCalendarIds(): string[] | undefined;
+    setVisiblePeopleMode(mode: VisiblePeopleMode): Promise<void>;
+    setVisiblePeopleIds(peopleIds: string[]): Promise<void>;
+    getVisiblePeopleIds(): string[] | undefined;
+    getVisiblePeopleMode(): PersonMode | null | undefined;
+    getIsLoaded(): boolean;
+}
+export declare type VisiblePeopleMode = 'custom' | 'me' | 'working';
+export interface RemotePreferencesStoreOptions {
+    connectToApi: () => Promise<MercuryClient>;
+}

package/build/stores/RemotePreferencesStore.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+class RemotePreferencesStore {
+    constructor(options) {
+        this.isLoaded = false;
+        const { connectToApi } = (0, schema_1.assertOptions)(options, ['connectToApi']);
+        this.connectToApi = connectToApi;
+    }
+    async load(organizationId) {
+        (0, schema_1.assertOptions)({ organizationId }, ['organizationId']);
+        this.organizationId = organizationId;
+        this.isLoaded = true;
+        this.client = await this.connectToApi();
+        await this.loadPreferences();
+    }
+    async loadPreferences() {
+        const [{ selectedCalendarIds, visiblePeopleMode, visiblePeopleIds }] = await this.client.emitAndFlattenResponses('calendar.get-preferences::v2021_05_19', {
+            target: {
+                organizationId: this.organizationId,
+            },
+        });
+        this.visibleCalendarIds = selectedCalendarIds !== null && selectedCalendarIds !== void 0 ? selectedCalendarIds : undefined;
+        this.visiblePeopleMode = visiblePeopleMode !== null && visiblePeopleMode !== void 0 ? visiblePeopleMode : undefined;
+        this.visiblePeopleIds = visiblePeopleIds !== null && visiblePeopleIds !== void 0 ? visiblePeopleIds : undefined;
+    }
+    async setVisibleCalendarIds(ids) {
+        this.visibleCalendarIds = ids;
+        await this.save();
+    }
+    async save() {
+        await this.client.emit('calendar.update-preferences::v2021_05_19', {
+            target: {
+                organizationId: this.organizationId,
+            },
+            payload: {
+                selectedCalendarIds: this.visibleCalendarIds,
+                visiblePeopleMode: this.visiblePeopleMode,
+                visiblePeopleIds: this.visiblePeopleIds,
+            },
+        });
+    }
+    getVisibleCalendarIds() {
+        if (!this.isLoaded) {
+            throw new Error(`You have to load the preferences store before getting selected calendar ids.`);
+        }
+        return this.visibleCalendarIds;
+    }
+    async setVisiblePeopleMode(mode) {
+        this.visiblePeopleMode = mode;
+        await this.save();
+    }
+    async setVisiblePeopleIds(peopleIds) {
+        this.visiblePeopleIds = peopleIds;
+        await this.save();
+    }
+    getVisiblePeopleIds() {
+        return this.visiblePeopleIds;
+    }
+    getVisiblePeopleMode() {
+        return this.visiblePeopleMode;
+    }
+    getIsLoaded() {
+        return this.isLoaded;
+    }
+}
+exports.default = RemotePreferencesStore;

package/build/toolBelt/CalendarToolTestFactory.d.ts

@@ -0,0 +1,5 @@
+import { ViewControllerId } from '@sprucelabs/heartwood-view-controllers';
+import { CalendarTool, CalendarToolBeltStateMachine, CalendarToolOptions } from '../types/calendar.types';
+export default class CalendarToolTestFactory {
+    static Tool(stateMachine: CalendarToolBeltStateMachine, vcId: ViewControllerId, options?: Partial<CalendarToolOptions>): CalendarTool;
+}

package/build/toolBelt/CalendarToolTestFactory.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@sprucelabs/schema");
+const test_1 = require("@sprucelabs/test");
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+class CalendarToolTestFactory {
+    static Tool(stateMachine, vcId, options) {
+        (0, schema_1.assertOptions)({ stateMachine, vcId }, ['stateMachine', 'vcId']);
+        const vc = stateMachine.Controller(vcId, Object.assign({ getContext: () => stateMachine.getContext(), updateContext: (context) => {
+                return stateMachine.updateContext(context);
+            }, getPersonFromEvent: () => {
+                throw new schema_1.SchemaError({
+                    code: 'MISSING_PARAMETERS',
+                    parameters: ['getPersonFromEvent'],
+                    friendlyMessage: `You need to pass 'getPersonFromEvent: () => login.getPerson()' or similar to CalendarToolTestFactory.Tool(....)`,
+                });
+            }, getHasPendingContextChanges: () => {
+                throw new schema_1.SchemaError({
+                    code: 'MISSING_PARAMETERS',
+                    parameters: ['getHasPendingContextChanges'],
+                    friendlyMessage: `You need to pass 'getHasPendingContextChanges: () => boolean' or similar to CalendarToolTestFactory.Tool(....)`,
+                });
+            } }, (0, cloneDeep_1.default)(options !== null && options !== void 0 ? options : {})));
+        void stateMachine.on('did-update-context', () => {
+            return vc.handleUpdateContext(stateMachine.getContext());
+        });
+        test_1.assert.isFunction(vc.handleUpdateContext, `You need to make sure your card view controller implements the CalendarTool interface!`);
+        return vc;
+    }
+}
+exports.default = CalendarToolTestFactory;

package/build/toolBelt/states/PrerequisitesToolBeltState.d.ts

@@ -0,0 +1,37 @@
+import { CardViewController, SpruceSchemas, ToolBeltState } from '@sprucelabs/heartwood-view-controllers';
+import { CalendarToolBeltStateMachine } from '../../types/calendar.types';
+declare type Calendar = SpruceSchemas.Calendar.v2021_05_19.Calendar;
+declare type EventType = SpruceSchemas.Calendar.v2021_05_19.CalendarEventType;
+declare type SelectCalendarHandler = (calendar: Calendar) => Promise<void> | void;
+declare type SelectTypeHandler = (type: EventType) => Promise<void> | void;
+export interface PrerequisitesToolBeltStateOptions {
+    onSelectCalendar?: SelectCalendarHandler;
+    onSelectEventType?: SelectTypeHandler;
+}
+export declare class PrerequisitesToolBeltState implements ToolBeltState {
+    readonly id = "prerequisites";
+    private calendarSelectCardVc?;
+    private typeSelectCardVc?;
+    private toolBeltVc;
+    private sm;
+    private calendars?;
+    private selectCalendarHandler?;
+    private selectEventTypeHandler?;
+    private calendar?;
+    constructor(options?: PrerequisitesToolBeltStateOptions);
+    load(stateMachine: CalendarToolBeltStateMachine): Promise<void>;
+    destroy(): void;
+    private setupCalendarSelectCard;
+    private handleSelectCalendar;
+    private setupTypeSelectCard;
+    private renderTypeButtonsSection;
+    private handleSelectType;
+    private updateEventInContext;
+    private TypeSelectCardVc;
+    getCalendarSelectCardVc(): CardViewController | undefined;
+    getTypeSelectCardVc(): CardViewController | undefined;
+    private SelectCalendarCardVc;
+    private listCalendars;
+    private connectToApi;
+}
+export {};