@sprucelabs/spruce-calendar-components 20.11.1 → 21.0.4

package/build/utilities/CalendarEventManager.js

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

package/build/utilities/CalendarPeopleManager.d.ts

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

package/build/utilities/CalendarPeopleManager.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mercury_event_emitter_1 = require("@sprucelabs/mercury-event-emitter");
+const mercury_types_1 = require("@sprucelabs/mercury-types");
+const schema_1 = require("@sprucelabs/schema");
+const spruce_core_schemas_1 = require("@sprucelabs/spruce-core-schemas");
+const SpruceError_1 = __importDefault(require("../errors/SpruceError"));
+class CalendarPeopleManager extends mercury_event_emitter_1.AbstractEventEmitter {
+    constructor(options) {
+        super(peopleContract);
+        this.team = [];
+        const { connectToApi, preferences, getVisibleEvents } = (0, schema_1.assertOptions)(options, ['connectToApi', 'preferences', 'calendarVc', 'getVisibleEvents']);
+        this.connectToApi = connectToApi;
+        this.prefs = preferences;
+        this.getVisibleEvents = getVisibleEvents;
+    }
+    async load(options) {
+        const { loggedInPerson, organizationId, locationId } = options !== null && options !== void 0 ? options : {};
+        this.client = await this.connectToApi();
+        this.loggedInPerson = loggedInPerson !== null && loggedInPerson !== void 0 ? loggedInPerson : undefined;
+        this.organizationId = organizationId;
+        this.locationId = locationId;
+        await this.loadTeam();
+        if (this.getVisiblePeople().length === 0 && this.loggedInPerson) {
+            await this.setVisiblePeopleIds([this.loggedInPerson.id]);
+        }
+    }
+    async loadTeam() {
+        const [{ people }] = await this.client.emitAndFlattenResponses('list-people::v2020_12_25', {
+            target: {
+                locationId: this.locationId,
+                organizationId: this.organizationId,
+            },
+            payload: {
+                roleBases: spruce_core_schemas_1.EMPLOYED_BASE_ROLES.map((r) => r.slug),
+            },
+        });
+        this.team = people;
+    }
+    getVisiblePeople() {
+        return this.getVisiblePeopleIds()
+            .map((i) => {
+            try {
+                return this.teammateById(i);
+                // eslint-disable-next-line no-empty
+            }
+            catch (_a) { }
+            return null;
+        })
+            .filter((t) => !!t);
+    }
+    teammateById(id) {
+        var _a;
+        const teammate = (_a = this.team) === null || _a === void 0 ? void 0 : _a.find((t) => t.id === id);
+        if (!teammate) {
+            throw new SpruceError_1.default({
+                code: 'PERSON_NOT_FOUND',
+                personId: id,
+            });
+        }
+        return teammate;
+    }
+    getTeam() {
+        return this.team;
+    }
+    getLoggedInPerson() {
+        return this.loggedInPerson;
+    }
+    getVisiblePeopleIds() {
+        var _a;
+        if (this.getVisibilityMode() === 'working') {
+            return this.getWorkingPeopleIds();
+        }
+        return (_a = this.getSavedVisiblePeopleIds()) !== null && _a !== void 0 ? _a : [];
+    }
+    getSavedVisiblePeopleIds() {
+        return this.prefs.getVisiblePeopleIds();
+    }
+    getVisibilityMode() {
+        var _a;
+        return (_a = this.prefs.getVisiblePeopleMode()) !== null && _a !== void 0 ? _a : 'me';
+    }
+    async setVisibilityMode(mode) {
+        if (this.getVisibilityMode() === mode) {
+            return;
+        }
+        await this.prefs.setVisiblePeopleMode(mode);
+        if (mode === 'me' && this.loggedInPerson) {
+            await this.setVisibilityToMe();
+        }
+        else if (mode === 'working') {
+            await this.setVisibleToWorking();
+        }
+    }
+    async setVisibilityToMe() {
+        if (this.loggedInPerson) {
+            await this.setVisiblePeopleIds([this.loggedInPerson.id], {
+                shouldForceEmitDidChange: true,
+            });
+        }
+    }
+    async setVisibleToWorking() {
+        const ids = this.getWorkingPeopleIds();
+        await this.setVisiblePeopleIds(ids);
+    }
+    getWorkingPeopleIds() {
+        return this.getWorkingPeople().map((i) => i.id);
+    }
+    getWorkingPeople() {
+        const events = this.getVisibleEvents();
+        let ids = events.map((e) => e.target.personId);
+        ids = ids.filter((id, idx) => ids.indexOf(id) === idx);
+        return ids
+            .map((id) => {
+            try {
+                return this.teammateById(id);
+                // eslint-disable-next-line no-empty
+            }
+            catch (_a) { }
+            return false;
+        })
+            .filter((p) => !!p);
+    }
+    async setVisiblePeopleIds(visible, options) {
+        var _a;
+        const { shouldForceEmitDidChange } = options !== null && options !== void 0 ? options : {};
+        const newVisibile = visible.filter((id, idx) => visible.indexOf(id) === idx);
+        const oldVisible = (_a = this.getSavedVisiblePeopleIds()) !== null && _a !== void 0 ? _a : [];
+        const newKey = newVisibile.join('');
+        const oldKey = oldVisible.join('');
+        const didChange = newKey !== oldKey;
+        if (didChange) {
+            await this.prefs.setVisiblePeopleIds(newVisibile);
+        }
+        if (didChange || shouldForceEmitDidChange) {
+            await this.emitDidUpdate();
+        }
+    }
+    async setPersonVisibility(id, shouldBeVisible) {
+        const person = this.teammateById(id);
+        let selected = [...this.getVisiblePeopleIds()];
+        if (shouldBeVisible) {
+            selected.push(person.id);
+        }
+        else {
+            selected = selected.filter((i) => i !== id);
+        }
+        await this.setVisibilityMode('custom');
+        await this.setVisiblePeopleIds(selected);
+    }
+    async emitDidUpdate() {
+        await this.emit('did-update');
+    }
+}
+exports.default = CalendarPeopleManager;
+const peopleContract = (0, mercury_types_1.buildEventContract)({
+    eventSignatures: {
+        'did-update': {},
+    },
+});

package/build/utilities/calendarShiftGenerator.d.ts

@@ -0,0 +1,8 @@
+import { SpruceSchemas } from '@sprucelabs/heartwood-view-controllers';
+export declare type CalendarShift = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarShift;
+import { EventForShift } from '../types/calendar.types';
+declare const calendarShiftGenerator: {
+    generateFromEvent(event: EventForShift): CalendarShift[];
+    generateFromEvents(events: EventForShift[]): CalendarShift[];
+};
+export default calendarShiftGenerator;

package/build/utilities/calendarShiftGenerator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const calendarShiftGenerator = {
+    generateFromEvent(event) {
+        let time = event.startDateTimeMs;
+        return event.timeBlocks.map((timeBlock, idx) => {
+            const end = time + timeBlock.durationMinutes * 60 * 1000;
+            const shift = {
+                id: event.id + '-' + idx,
+                startDateTimeMs: time,
+                endDateTimeMs: end,
+                personId: event.target.personId,
+            };
+            time = end;
+            return shift;
+        });
+    },
+    generateFromEvents(events) {
+        const shifts = events.reduce((shifts, event) => {
+            shifts.push(...this.generateFromEvent(event));
+            return shifts;
+        }, []);
+        return shifts;
+    },
+};
+exports.default = calendarShiftGenerator;

package/build/viewControllers/CalendarSelectTool.vc.d.ts

@@ -0,0 +1,28 @@
+import { AbstractViewController, ActiveRecordCardViewController, Scope, SpruceSchemas, ViewControllerOptions } from '@sprucelabs/heartwood-view-controllers';
+import { CalendarEventManager } from '../utilities/CalendarEventManager';
+export default class CalendarSelectCardViewController extends AbstractViewController<Card> {
+    static id: string;
+    private isLoaded;
+    private activeVc;
+    private events;
+    private selectedCalendarIds;
+    private changePromise?;
+    constructor(options: ViewControllerOptions & CalendarSelectCardOptions);
+    private CalendarListVc;
+    private renderCalendarRow;
+    waitForChanges(): Promise<void>;
+    getActiveRecordCardVc(): ActiveRecordCardViewController;
+    getListVc(): import("@sprucelabs/heartwood-view-controllers").ListViewController;
+    getIsLoaded(): boolean;
+    getSelectedCalendarIds(): string[];
+    load(options: {
+        scope: Scope;
+    }): Promise<void>;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Card;
+}
+declare type Card = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Card;
+export declare type CalendarVisibilityToggleHandler = (calendarId: string, isVisible: boolean) => any;
+export interface CalendarSelectCardOptions {
+    events: CalendarEventManager;
+}
+export {};

package/build/viewControllers/CalendarSelectTool.vc.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const heartwood_view_controllers_1 = require("@sprucelabs/heartwood-view-controllers");
+const schema_1 = require("@sprucelabs/schema");
+class CalendarSelectCardViewController extends heartwood_view_controllers_1.AbstractViewController {
+    constructor(options) {
+        super(options);
+        this.isLoaded = false;
+        this.selectedCalendarIds = [];
+        const { events } = (0, schema_1.assertOptions)(options, ['events']);
+        this.events = events;
+        this.selectedCalendarIds = this.events.getVisibleCalendarIds();
+        this.activeVc = this.CalendarListVc();
+    }
+    CalendarListVc() {
+        return this.Controller('activeRecordCard', (0, heartwood_view_controllers_1.buildActiveRecordCard)({
+            shouldRenderRowDividers: true,
+            columnWidths: ['fill'],
+            header: {
+                title: 'Calendars',
+            },
+            noResultsRow: {
+                cells: [
+                    {
+                        text: { content: "You don't have any calendars yet!" },
+                    },
+                ],
+            },
+            eventName: 'calendar.list-calendars::v2021_05_19',
+            rowTransformer: this.renderCalendarRow.bind(this),
+            responseKey: 'calendars',
+        }));
+    }
+    renderCalendarRow(calendar) {
+        return {
+            id: calendar.id,
+            cells: [
+                {
+                    text: { content: calendar.title },
+                },
+                {
+                    toggleInput: {
+                        name: 'isVisible',
+                        value: this.selectedCalendarIds.indexOf(calendar.id) > -1,
+                        onChange: async (isVisible) => {
+                            this.changePromise = this.events.setCalendarVisibility(calendar.id, isVisible);
+                            return this.changePromise;
+                        },
+                    },
+                },
+            ],
+        };
+    }
+    async waitForChanges() {
+        await this.changePromise;
+    }
+    getActiveRecordCardVc() {
+        return this.activeVc;
+    }
+    getListVc() {
+        return this.activeVc.getListVc();
+    }
+    getIsLoaded() {
+        return this.isLoaded;
+    }
+    getSelectedCalendarIds() {
+        const records = this.activeVc.getRecords();
+        const ids = [];
+        for (const calendar of records) {
+            if (this.getListVc().getRowVc(calendar.id).getValue('isVisible')) {
+                ids.push(calendar.id);
+            }
+        }
+        return ids;
+    }
+    async load(options) {
+        (0, schema_1.assertOptions)(options, ['scope']);
+        const { scope } = options;
+        const org = await scope.getCurrentOrganization();
+        if (org) {
+            this.activeVc.setTarget({
+                organizationId: org === null || org === void 0 ? void 0 : org.id,
+            });
+        }
+        await this.activeVc.load();
+        this.isLoaded = true;
+    }
+    render() {
+        return this.activeVc.render();
+    }
+}
+exports.default = CalendarSelectCardViewController;
+CalendarSelectCardViewController.id = 'calendar-select-tool';

package/build/viewControllers/DateSelectCard.vc.d.ts

@@ -0,0 +1,29 @@
+import { AbstractViewController, CalendarViewController, SpruceSchemas, ViewControllerOptions } from '@sprucelabs/heartwood-view-controllers';
+declare type Card = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Card;
+declare type DateSelectHandler = (dateTimeMs: number) => void | Promise<void>;
+export interface DateSelectOptions {
+    onSelectDate: DateSelectHandler;
+    startDate: number;
+    selectedDate?: {
+        year: number;
+        month: number;
+        day: number;
+    };
+}
+export default class DateSelectCardViewController extends AbstractViewController<Card> {
+    static id: string;
+    private cardVc;
+    private calendarVc;
+    private dateSelectHandler;
+    constructor(options: ViewControllerOptions & DateSelectOptions);
+    getStartDate(): number | null | undefined;
+    setStartDate(startDate: number): void;
+    private CalendarVc;
+    private handleDateSelect;
+    private CardVc;
+    setSelectedDate(year: number, month: number, day: number): void;
+    getSelectedDate(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarSelectedDate;
+    getCalendarVc(): CalendarViewController;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Card;
+}
+export {};