@sprucelabs/spruce-calendar-components 21.0.2 → 21.0.5

package/build/esm/skillViewControllers/Root.svc.js

@@ -0,0 +1,404 @@
+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 { AbstractSkillViewController, ToolBeltStateMachine, } from '@sprucelabs/heartwood-view-controllers';
+import { RemoteViewControllerFactory } from '@sprucelabs/spruce-heartwood-utils';
+import RemoteEventStore from '../stores/RemoteEventStore.js';
+import RemotePreferencesStore from '../stores/RemotePreferencesStore.js';
+import { PrerequisitesToolBeltState } from '../toolBelt/states/PrerequisitesToolBeltState.js';
+import { RootToolBeltState } from '../toolBelt/states/RootToolBeltState.js';
+import { CalendarEventManager } from '../utilities/CalendarEventManager.js';
+import CalendarPeopleManager from '../utilities/CalendarPeopleManager.js';
+export default class RootSkillViewController extends AbstractSkillViewController {
+    constructor(options) {
+        super(options);
+        this.getScope = () => ['employed', 'location'];
+        this.toolBeltVc = this.ToolBeltVc();
+        this.calendarVc = this.CalendarVc();
+        this.sm = this.ToolBeltStateMachine();
+        this.remoteVc = RemoteViewControllerFactory.Factory({
+            connectToApi: this.connectToApi.bind(this),
+            vcFactory: this.getVcFactory(),
+        });
+        this.remoteEventStore = new RemoteEventStore({
+            connectToApi: this.connectToApi.bind(this),
+        });
+        this.preferences = new RemotePreferencesStore({
+            connectToApi: this.connectToApi.bind(this),
+        });
+        this.people = new CalendarPeopleManager({
+            connectToApi: this.connectToApi.bind(this),
+            preferences: this.preferences,
+            calendarVc: this.calendarVc,
+            getVisibleEvents: this.getVisibleEvents.bind(this),
+        });
+        this.events = new 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({
+                people: this.people,
+                events: this.events,
+            }),
+            prerequisites: new PrerequisitesToolBeltState({
+                onSelectCalendar: this.handleSelectCalendar.bind(this),
+                onSelectEventType: this.handleSelectEventType.bind(this),
+            }),
+        };
+    }
+    ToolBeltStateMachine() {
+        const sm = new ToolBeltStateMachine({
+            toolBeltVc: this.toolBeltVc,
+            vcFactory: this.getVcFactory(),
+            connectToApi: this.connectToApi.bind(this),
+            context: {
+                calendarVc: this.calendarVc,
+                cancelEvent: (eventId) => this.handleCancelEvent(eventId),
+            },
+        });
+        return sm;
+    }
+    handleCancelEvent(eventId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const confirm = yield this.confirm({
+                title: 'Cancel?',
+                message: `You wanna cancel this?`,
+            });
+            if (confirm) {
+                yield this.events.removeEvent(eventId);
+            }
+        });
+    }
+    askForUpdateStrategy(cleaned) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let strategy;
+            const dlg = this.renderInDialog(Object.assign({ shouldShowCloseButton: false }, this.Controller('calendar.select-update-repeating-strategy-card', {
+                event: cleaned,
+                onSelectStrategy: (s) => __awaiter(this, void 0, void 0, function* () {
+                    strategy = s;
+                    yield dlg.hide();
+                }),
+            }).render()));
+            yield dlg.wait();
+            return strategy;
+        });
+    }
+    handleSelectEventType(type) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.selectingTypePromise = new Promise((resolve) => {
+                this.selectingTypeResolve = resolve;
+            });
+            if (type.viewControllerId) {
+                try {
+                    yield this.events.setupVcForEventType(type.viewControllerId, type.slug);
+                    yield this.transitionToStateFromDraftEvent();
+                }
+                catch (err) {
+                    (_a = this.selectingTypeResolve) === null || _a === void 0 ? void 0 : _a.call(this);
+                    console.error(err);
+                    yield 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!`,
+                    });
+                    yield this.restoreDraftAfterStateLoadError();
+                    return;
+                }
+            }
+            (_b = this.selectingTypeResolve) === null || _b === void 0 ? void 0 : _b.call(this);
+        });
+    }
+    restoreDraftAfterStateLoadError() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitUntilDoneSaving();
+            yield this.sm.waitForContextUpdate();
+            void this.transitionTo(this.toolBeltStates.prerequisites);
+            yield this.events.restoreEventToDraftOnStateLoadError();
+        });
+    }
+    transitionToStateFromDraftEvent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { event } = this.sm.getContext();
+            yield this.transitionToolBeltForEvent(event.id);
+        });
+    }
+    transitionToolBeltForEvent(eventId) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const vc = this.calendarVc.getEventVc(eventId);
+            const state = (_a = vc.getToolBeltState) === null || _a === void 0 ? void 0 : _a.call(vc);
+            if (state) {
+                yield this.transitionTo(state);
+            }
+        });
+    }
+    transitionTo(state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sm.transitionTo(state);
+        });
+    }
+    waitUntilDoneSaving() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield 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),
+        });
+    }
+    handleChangeDate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.makeDateSelectMatchSelectedDateFromCalendar();
+            yield 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();
+    }
+    handleDeselectEvent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.calendarVc.getIsSwappingEvent()) {
+                return;
+            }
+            yield this.resetToRootState();
+        });
+    }
+    resetToRootState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.events.reset();
+            this.makeDateSelectMatchSelectedDateFromCalendar();
+            this.transitionPromise = this.sm.transitionTo(this.toolBeltStates.root);
+            this.toolBeltVc.close();
+            yield this.transitionPromise;
+        });
+    }
+    ToolBeltVc() {
+        return this.Controller('toolBelt', {
+            shouldRenderAllToolsAtOnce: true,
+        });
+    }
+    handleClickEvent(options) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { event } = options;
+            yield this.events.selectEvent(event.id);
+            this.toolBeltVc.open({ shouldStayOpen: true });
+            try {
+                if (!event.eventTypeSlug) {
+                    yield this.transitionTo(this.toolBeltStates.prerequisites);
+                }
+                else {
+                    yield this.transitionToolBeltForEvent(event.id);
+                }
+            }
+            catch (err) {
+                console.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+                this.calendarVc.deselectEvent();
+                yield this.alert({
+                    message: (_b = err.message) !== null && _b !== void 0 ? _b : 'Shoot! I could not load that for you! Refresh and try again!!',
+                });
+            }
+        });
+    }
+    handleDraftEventAdded(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!event.eventTypeSlug) {
+                yield this.events.addDraftEvent(event);
+                this.toolBeltVc.open({ shouldStayOpen: true });
+                yield this.sm.transitionTo(this.toolBeltStates.prerequisites);
+            }
+        });
+    }
+    handleEventSwapped(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.events.silentlySwapEvent(this.sm.getContext().event.id, event);
+        });
+    }
+    handleDropEvent(id, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.events.handleDropEvent(id, updates);
+        });
+    }
+    handleDraftEventRemoved() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    getPersonSelectVc() {
+        return this.toolBeltStates.root.getPersonSelectCardVc();
+    }
+    renderToolBelt() {
+        return this.toolBeltVc.render();
+    }
+    getCalendarSelectVc() {
+        return this.toolBeltStates.root.getCalendarSelectCardVc();
+    }
+    getCalendarVc() {
+        return this.calendarVc;
+    }
+    load(options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sm.updateContext(Object.assign(Object.assign({}, options), { people: this.people, events: this.events }));
+            this.client = yield this.connectToApi();
+            const { scope, locale, args, router } = options;
+            yield locale.on('did-change-timezones', () => {
+                return this.syncOffsetWithLocale(locale);
+            });
+            const [location] = yield 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 {
+                yield this.preferences.load(this.organizationId);
+                yield this.people.on('did-update', this.syncPeopleOnCalendar.bind(this));
+                yield this.people.load({
+                    loggedInPerson: this.person,
+                    locationId: this.locationId,
+                    organizationId: this.organizationId,
+                });
+                yield this.remoteEventStore.load({
+                    locationId: this.locationId,
+                    organizationId: this.organizationId,
+                });
+                yield this.events.load();
+            }
+            catch (err) {
+                yield this.alert({
+                    message: (_a = err.message) !== null && _a !== void 0 ? _a : 'Something catastrophic happened! We gotta get out of there!',
+                });
+                yield router.redirect('heartwood.root');
+            }
+            const { startDate = this.dates.date() } = args;
+            yield this.calendarVc.renderOnce(() => {
+                this.syncOffsetWithLocale(locale);
+                this.calendarVc.setStartDate(startDate);
+            });
+            yield this.transitionToRoot();
+            this.setSelectedDateInDateSelectVc(startDate);
+            yield this.waitUntilDoneSaving();
+        });
+    }
+    syncPeopleOnCalendar() {
+        const visiblePeople = this.people.getVisiblePeople();
+        this.calendarVc.setPeople(visiblePeople);
+    }
+    syncOffsetWithLocale(locale) {
+        const offset = locale.getTimezoneOffsetMinutes();
+        this.calendarVc.setTimezoneOffsetMs(offset * 60 * 1000);
+    }
+    loadEvents() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.loadEventsPromise = this._loadEvents();
+            yield this.loadEventsPromise;
+        });
+    }
+    _loadEvents() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.events.getCalendars().length > 0) {
+                    const date = this.getStartDate();
+                    const startDate = this.dates.getStartOfDay(date);
+                    const endDate = this.dates.getEndOfDay(date);
+                    yield this.events.loadEvents(startDate, endDate, this.people.getTeam().map((t) => t.id));
+                    yield 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,
+                });
+            }
+        });
+    }
+    transitionToRoot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sm.transitionTo(this.toolBeltStates.root);
+        });
+    }
+    loadLoggedInPerson() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [{ auth }] = yield 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(),
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+}
+RootSkillViewController.id = 'root';

package/build/esm/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/esm/toolBelt/CalendarToolTestFactory.js

@@ -0,0 +1,28 @@
+import { assertOptions, SchemaError } from '@sprucelabs/schema';
+import { assert } from '@sprucelabs/test';
+import cloneDeep from 'lodash/cloneDeep.js';
+export default class CalendarToolTestFactory {
+    static Tool(stateMachine, vcId, options) {
+        assertOptions({ stateMachine, vcId }, ['stateMachine', 'vcId']);
+        const vc = stateMachine.Controller(vcId, Object.assign({ getContext: () => stateMachine.getContext(), updateContext: (context) => {
+                return stateMachine.updateContext(context);
+            }, getPersonFromEvent: () => {
+                throw new SchemaError({
+                    code: 'MISSING_PARAMETERS',
+                    parameters: ['getPersonFromEvent'],
+                    friendlyMessage: `You need to pass 'getPersonFromEvent: () => login.getPerson()' or similar to CalendarToolTestFactory.Tool(....)`,
+                });
+            }, getHasPendingContextChanges: () => {
+                throw new SchemaError({
+                    code: 'MISSING_PARAMETERS',
+                    parameters: ['getHasPendingContextChanges'],
+                    friendlyMessage: `You need to pass 'getHasPendingContextChanges: () => boolean' or similar to CalendarToolTestFactory.Tool(....)`,
+                });
+            } }, cloneDeep(options !== null && options !== void 0 ? options : {})));
+        void stateMachine.on('did-update-context', () => {
+            return vc.handleUpdateContext(stateMachine.getContext());
+        });
+        assert.isFunction(vc.handleUpdateContext, `You need to make sure your card view controller implements the CalendarTool interface!`);
+        return vc;
+    }
+}

package/build/esm/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 {};

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();
+        });
+    }
+}