@sprucelabs/spruce-calendar-components 21.0.3 → 21.0.4

package/build/esm/utilities/CalendarPeopleManager.js

@@ -0,0 +1,182 @@
+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 { AbstractEventEmitter } from '@sprucelabs/mercury-event-emitter';
+import { buildEventContract } from '@sprucelabs/mercury-types';
+import { assertOptions } from '@sprucelabs/schema';
+import { EMPLOYED_BASE_ROLES } from '@sprucelabs/spruce-core-schemas';
+import SpruceError from '../errors/SpruceError.js';
+export default class CalendarPeopleManager extends AbstractEventEmitter {
+    constructor(options) {
+        super(peopleContract);
+        this.team = [];
+        const { connectToApi, preferences, getVisibleEvents } = assertOptions(options, ['connectToApi', 'preferences', 'calendarVc', 'getVisibleEvents']);
+        this.connectToApi = connectToApi;
+        this.prefs = preferences;
+        this.getVisibleEvents = getVisibleEvents;
+    }
+    load(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { loggedInPerson, organizationId, locationId } = options !== null && options !== void 0 ? options : {};
+            this.client = yield this.connectToApi();
+            this.loggedInPerson = loggedInPerson !== null && loggedInPerson !== void 0 ? loggedInPerson : undefined;
+            this.organizationId = organizationId;
+            this.locationId = locationId;
+            yield this.loadTeam();
+            if (this.getVisiblePeople().length === 0 && this.loggedInPerson) {
+                yield this.setVisiblePeopleIds([this.loggedInPerson.id]);
+            }
+        });
+    }
+    loadTeam() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [{ people }] = yield this.client.emitAndFlattenResponses('list-people::v2020_12_25', {
+                target: {
+                    locationId: this.locationId,
+                    organizationId: this.organizationId,
+                },
+                payload: {
+                    roleBases: 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({
+                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';
+    }
+    setVisibilityMode(mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.getVisibilityMode() === mode) {
+                return;
+            }
+            yield this.prefs.setVisiblePeopleMode(mode);
+            if (mode === 'me' && this.loggedInPerson) {
+                yield this.setVisibilityToMe();
+            }
+            else if (mode === 'working') {
+                yield this.setVisibleToWorking();
+            }
+        });
+    }
+    setVisibilityToMe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.loggedInPerson) {
+                yield this.setVisiblePeopleIds([this.loggedInPerson.id], {
+                    shouldForceEmitDidChange: true,
+                });
+            }
+        });
+    }
+    setVisibleToWorking() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ids = this.getWorkingPeopleIds();
+            yield 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);
+    }
+    setVisiblePeopleIds(visible, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            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) {
+                yield this.prefs.setVisiblePeopleIds(newVisibile);
+            }
+            if (didChange || shouldForceEmitDidChange) {
+                yield this.emitDidUpdate();
+            }
+        });
+    }
+    setPersonVisibility(id, shouldBeVisible) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const person = this.teammateById(id);
+            let selected = [...this.getVisiblePeopleIds()];
+            if (shouldBeVisible) {
+                selected.push(person.id);
+            }
+            else {
+                selected = selected.filter((i) => i !== id);
+            }
+            yield this.setVisibilityMode('custom');
+            yield this.setVisiblePeopleIds(selected);
+        });
+    }
+    emitDidUpdate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.emit('did-update');
+        });
+    }
+}
+const peopleContract = buildEventContract({
+    eventSignatures: {
+        'did-update': {},
+    },
+});

package/build/esm/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/esm/utilities/calendarShiftGenerator.js

@@ -0,0 +1,24 @@
+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;
+    },
+};
+export default calendarShiftGenerator;

package/build/esm/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/esm/viewControllers/CalendarSelectTool.vc.js

@@ -0,0 +1,103 @@
+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 { AbstractViewController, buildActiveRecordCard, } from '@sprucelabs/heartwood-view-controllers';
+import { assertOptions } from '@sprucelabs/schema';
+export default class CalendarSelectCardViewController extends AbstractViewController {
+    constructor(options) {
+        super(options);
+        this.isLoaded = false;
+        this.selectedCalendarIds = [];
+        const { events } = assertOptions(options, ['events']);
+        this.events = events;
+        this.selectedCalendarIds = this.events.getVisibleCalendarIds();
+        this.activeVc = this.CalendarListVc();
+    }
+    CalendarListVc() {
+        return this.Controller('activeRecordCard', 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: (isVisible) => __awaiter(this, void 0, void 0, function* () {
+                            this.changePromise = this.events.setCalendarVisibility(calendar.id, isVisible);
+                            return this.changePromise;
+                        }),
+                    },
+                },
+            ],
+        };
+    }
+    waitForChanges() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield 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;
+    }
+    load(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            assertOptions(options, ['scope']);
+            const { scope } = options;
+            const org = yield scope.getCurrentOrganization();
+            if (org) {
+                this.activeVc.setTarget({
+                    organizationId: org === null || org === void 0 ? void 0 : org.id,
+                });
+            }
+            yield this.activeVc.load();
+            this.isLoaded = true;
+        });
+    }
+    render() {
+        return this.activeVc.render();
+    }
+}
+CalendarSelectCardViewController.id = 'calendar-select-tool';

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

package/build/esm/viewControllers/DateSelectCard.vc.js

@@ -0,0 +1,77 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { dateUtil } from '@sprucelabs/calendar-utils';
+import { AbstractViewController, } from '@sprucelabs/heartwood-view-controllers';
+import { assertOptions } from '@sprucelabs/schema';
+export default class DateSelectCardViewController extends AbstractViewController {
+    constructor(options) {
+        super(options);
+        const { onSelectDate, startDate, selectedDate } = assertOptions(options, [
+            'onSelectDate',
+            'startDate',
+        ]);
+        this.dateSelectHandler = onSelectDate;
+        this.calendarVc = this.CalendarVc({
+            startDate,
+            selectedDates: selectedDate ? [selectedDate] : [],
+        });
+        this.cardVc = this.CardVc();
+    }
+    getStartDate() {
+        return this.calendarVc.getStartDate();
+    }
+    setStartDate(startDate) {
+        this.calendarVc.setStartDate(startDate);
+    }
+    CalendarVc(options) {
+        return this.Controller('calendar', Object.assign({ view: 'month', onClick: ({ dateTimeMs }) => this.handleDateSelect(dateTimeMs), selectedDates: [] }, options));
+    }
+    handleDateSelect(dateTimeMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { year, month, day } = dateUtil.splitDate(dateTimeMs);
+            yield this.calendarVc.renderOnce(() => {
+                this.calendarVc.setStartDate(dateTimeMs);
+                this.calendarVc.clearSelectedDates();
+                this.calendarVc.selectDate(year, month, day);
+            });
+            yield this.dateSelectHandler(dateTimeMs !== null && dateTimeMs !== void 0 ? dateTimeMs : 0);
+        });
+    }
+    CardVc() {
+        return this.Controller('card', {
+            body: {
+                sections: [
+                    {
+                        calendar: this.calendarVc.render(),
+                    },
+                ],
+            },
+        });
+    }
+    setSelectedDate(year, month, day) {
+        this.calendarVc.setSelectedDates([
+            {
+                year,
+                month,
+                day,
+            },
+        ]);
+    }
+    getSelectedDate() {
+        return this.calendarVc.getSelectedDates()[0];
+    }
+    getCalendarVc() {
+        return this.calendarVc;
+    }
+    render() {
+        return this.cardVc.render();
+    }
+}
+DateSelectCardViewController.id = 'date-select-card';

package/build/esm/viewControllers/PersonSelectTool.vc.d.ts

@@ -0,0 +1,36 @@
+import { AbstractViewController, SpruceSchemas, ViewControllerOptions, ButtonBarViewController, Card, ListViewController } from '@sprucelabs/heartwood-view-controllers';
+import CalendarPeopleManager from '../utilities/CalendarPeopleManager';
+export default class PersonSelectToolViewController extends AbstractViewController<Card> {
+    static id: string;
+    private shouldUpdateVisibilityOnToggleChange;
+    private updatePromise?;
+    private get visiblePeopleIds();
+    private isLoaded;
+    private get loggedInPersonId();
+    private cardVc;
+    private listVc;
+    private modeButtonBarVc;
+    private get mode();
+    private people;
+    constructor(options: ViewControllerOptions & PersonSelectCardOptions);
+    private CardVc;
+    private ModeButtonBarVc;
+    waitForSave(): Promise<void | undefined>;
+    private ListVc;
+    private renderRow;
+    private handleChangeMode;
+    getModeButtonBar(): ButtonBarViewController;
+    load(): Promise<void>;
+    private handlePeopleUpdated;
+    getListVc(): ListViewController;
+    getMode(): PersonMode;
+    setMode(mode: PersonMode): Promise<void>;
+    getIsLoaded(): boolean;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Card;
+}
+export declare type PersonVisibilityToggleHandler = (person: SpruceSchemas.Spruce.v2020_07_22.Person, isVisible: boolean) => void;
+export declare type PersonVisibilytModeToggleHandler = (mode: PersonMode) => Promise<void> | void;
+export declare type PersonMode = 'me' | 'custom' | 'working';
+export interface PersonSelectCardOptions {
+    people: CalendarPeopleManager;
+}

package/build/esm/viewControllers/PersonSelectTool.vc.js

@@ -0,0 +1,156 @@
+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 { AbstractViewController, } from '@sprucelabs/heartwood-view-controllers';
+import { assertOptions } from '@sprucelabs/schema';
+export default class PersonSelectToolViewController extends AbstractViewController {
+    constructor(options) {
+        super(options);
+        this.shouldUpdateVisibilityOnToggleChange = true;
+        this.isLoaded = false;
+        const { people } = assertOptions(options, ['people']);
+        this.people = people;
+        this.listVc = this.ListVc();
+        this.modeButtonBarVc = this.ModeButtonBarVc();
+        this.cardVc = this.CardVc();
+    }
+    get visiblePeopleIds() {
+        return this.people.getVisiblePeople().map((p) => p.id);
+    }
+    get loggedInPersonId() {
+        var _a;
+        return (_a = this.people.getLoggedInPerson()) === null || _a === void 0 ? void 0 : _a.id;
+    }
+    get mode() {
+        return this.people.getVisibilityMode();
+    }
+    CardVc() {
+        return this.Controller('card', {
+            header: {
+                title: 'People',
+            },
+            body: {
+                sections: [
+                    {
+                        buttonBar: this.modeButtonBarVc.render(),
+                    },
+                    {
+                        list: this.listVc.render(),
+                        shouldBePadded: false,
+                    },
+                ],
+            },
+        });
+    }
+    ModeButtonBarVc() {
+        return this.Controller('buttonBar', {
+            selected: [this.mode],
+            onSelectionChange: this.handleChangeMode.bind(this),
+            buttons: [
+                {
+                    id: 'custom',
+                    label: 'Custom',
+                    lineIcon: 'users',
+                },
+                {
+                    id: 'working',
+                    label: 'Working',
+                    lineIcon: 'clipboard',
+                },
+                {
+                    id: 'me',
+                    label: 'Me',
+                    lineIcon: 'user',
+                },
+            ],
+        });
+    }
+    waitForSave() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.updatePromise;
+        });
+    }
+    ListVc() {
+        return this.Controller('list', {
+            columnWidths: ['fill'],
+            rows: this.people.getTeam().map((p) => this.renderRow(p)),
+        });
+    }
+    renderRow(person) {
+        return {
+            id: person.id,
+            cells: [
+                {
+                    text: {
+                        content: person.id === this.loggedInPersonId ? 'You' : person.casualName,
+                    },
+                },
+                {
+                    toggleInput: {
+                        name: 'isVisible',
+                        value: !!this.visiblePeopleIds.find((id) => id === person.id),
+                        onChange: (value) => __awaiter(this, void 0, void 0, function* () {
+                            if (this.shouldUpdateVisibilityOnToggleChange) {
+                                this.updatePromise = this.people.setPersonVisibility(person.id, value !== null && value !== void 0 ? value : false);
+                            }
+                        }),
+                    },
+                },
+            ],
+        };
+    }
+    handleChangeMode() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.people.setVisibilityMode(this.getMode());
+        });
+    }
+    getModeButtonBar() {
+        return this.modeButtonBarVc;
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.isLoaded = true;
+            yield this.people.on('did-update', this.handlePeopleUpdated.bind(this));
+        });
+    }
+    handlePeopleUpdated() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.getMode() !== this.people.getVisibilityMode()) {
+                yield this.setMode(this.people.getVisibilityMode());
+            }
+            const rows = this.listVc.getRowVcs();
+            const visiblePeople = this.people.getVisiblePeople().map((p) => p.id);
+            this.shouldUpdateVisibilityOnToggleChange = false;
+            yield Promise.all(rows.map((row) => __awaiter(this, void 0, void 0, function* () {
+                const shouldBeSelected = visiblePeople.indexOf(row.getId()) > -1;
+                yield row.setValue('isVisible', shouldBeSelected);
+            })));
+            this.shouldUpdateVisibilityOnToggleChange = true;
+        });
+    }
+    getListVc() {
+        return this.listVc;
+    }
+    getMode() {
+        const [mode] = this.modeButtonBarVc.getSelectedButtons();
+        return mode;
+    }
+    setMode(mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.modeButtonBarVc.selectButtons([mode]);
+        });
+    }
+    getIsLoaded() {
+        return this.isLoaded;
+    }
+    render() {
+        return this.cardVc.render();
+    }
+}
+PersonSelectToolViewController.id = 'person-select-tool';

package/build/esm/viewControllers/SelectUpdateRepeatingStrategyCard.vc.d.ts

@@ -0,0 +1,18 @@
+import { AbstractViewController, SpruceSchemas, ViewControllerOptions } from '@sprucelabs/heartwood-view-controllers';
+import { CalendarEvent, UpdateRepeatingStrategyWithCancel } from '../types/calendar.types';
+export default class SelectUpdateRepeatingStrategyCardViewController extends AbstractViewController<Card> {
+    static id: string;
+    private cardVc;
+    private event;
+    private onSelectStrategy;
+    constructor(options: ViewControllerOptions & SelectUpdateRepeatingStrategyOptions);
+    private CardVc;
+    getEvent(): CalendarEvent;
+    render(): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Card;
+}
+declare type Card = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Card;
+export interface SelectUpdateRepeatingStrategyOptions {
+    event: CalendarEvent;
+    onSelectStrategy: (strategy: UpdateRepeatingStrategyWithCancel) => Promise<void> | void;
+}
+export {};