@sprucelabs/spruce-calendar-components 20.11.1 → 21.0.4

package/build/esm/utilities/CalendarEventManager.js

@@ -0,0 +1,321 @@
+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 { calendarEventSchema, } from '@sprucelabs/heartwood-view-controllers';
+import { assertOptions, normalizeSchemaValues } from '@sprucelabs/schema';
+import SpruceError from '../errors/SpruceError.js';
+import calendarShiftGenerator from './calendarShiftGenerator.js';
+import draftEventGenerator from './draftGenerator.js';
+export 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, } = 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.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;
+    }
+    addDraftEvent(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.calendarVc.selectEvent(event.id);
+            this.allEvents.push(event);
+            yield this.updateEventInContext(event);
+        });
+    }
+    silentlySwapEvent(oldId, event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const events = this.getAllEvents().filter((e) => e.id !== oldId);
+            this.allEvents = [...events, event];
+            yield this.updateEventInContext(event);
+        });
+    }
+    handleDropEvent(id, updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const event = Object.assign(Object.assign({}, this.calendarVc.getEvent(id)), updates);
+            const pass = yield this.optionallyAskForUpdateRepeatingStrategy(event);
+            if (pass) {
+                yield this.saveEvent(event);
+            }
+            return pass;
+        });
+    }
+    reset() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            void this.setEventInContext(undefined);
+            (_a = this.events) === null || _a === void 0 ? void 0 : _a.clearCalendarId();
+        });
+    }
+    restoreEventToDraftOnStateLoadError() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const updated = yield this.updateEventInContext({
+                timeBlocks: draftEventGenerator.generateTimeBlocks(),
+                calendarId: undefined,
+                eventTypeSlug: undefined,
+            });
+            this.updateEvent(updated.id, updated);
+        });
+    }
+    getVisibleCalendarIds() {
+        return this.visibleCalendarIds;
+    }
+    removeEvent(id) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.allEvents = this.allEvents.filter((e) => e.id !== id);
+            const event = this.calendarVc.getEvent(id);
+            this.calendarVc.removeEvent(id);
+            try {
+                yield 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 }));
+            }
+        });
+    }
+    makeCalendarVisible(calendarId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertValidCalendarId(calendarId);
+            this.calendarVc.mixinEvents(this.allEvents.filter((e) => e.calendarId === calendarId));
+            const visibleCalendarIds = [...this.visibleCalendarIds];
+            visibleCalendarIds.push(calendarId);
+            yield this.prefs.setVisibleCalendarIds(visibleCalendarIds);
+        });
+    }
+    makeCalendarHidden(calendarId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+                }
+            }
+            yield 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;
+    }
+    loadEvents(startDate, endDate, peopleIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const events = yield this.events.getSchedules({
+                calendarIds: this.calendarIds,
+                startDate,
+                endDate,
+                peopleIds,
+            });
+            this.replaceEventsInRange(events, startDate, endDate);
+            if (!this.eventTypes) {
+                this.eventTypes = yield this.events.loadEventTypes();
+            }
+            yield Promise.all(events.map((e) => __awaiter(this, void 0, void 0, function* () {
+                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) {
+                    yield this.setupVcForEventType(type.viewControllerId, type.slug);
+                }
+            })));
+        });
+    }
+    setCalendarVisibility(calendarId, shouldBeVisible) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (shouldBeVisible) {
+                yield this.makeCalendarVisible(calendarId);
+            }
+            else {
+                yield this.makeCalendarHidden(calendarId);
+            }
+        });
+    }
+    setupVcForEventType(vcId, typeSlug) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.hasVcForEventTypeBeenLoaded[vcId]) {
+                return;
+            }
+            this.hasVcForEventTypeBeenLoaded[vcId] = true;
+            yield this.remoteVc.fetchRemoteController(vcId);
+            this.calendarVc.setControllerForEventType(typeSlug, vcId);
+        });
+    }
+    assertValidCalendarId(calendarId) {
+        if (!this.doesCalenderExist(calendarId)) {
+            throw new SpruceError({
+                code: 'CALENDAR_NOT_FOUND',
+                calendarIds: [calendarId],
+            });
+        }
+    }
+    updateEventInContext(updates) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { event } = this.sm.getContext();
+            const updated = Object.assign(Object.assign(Object.assign({}, event), updates), { isBusy: false });
+            yield this.setEventInContext(updated);
+            return updated;
+        });
+    }
+    setEventInContext(newEvent, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.shouldIgnoreNextContextUpdate =
+                (options === null || options === void 0 ? void 0 : options.shouldHandleDidUpdateContext) !== false;
+            yield this.sm.updateContext({
+                event: newEvent,
+            });
+        });
+    }
+    selectEvent(eventId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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) {
+                yield this.setEventInContext(event);
+            }
+        });
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sm.on('will-update-context', this.handleWillUpdateContext.bind(this));
+            yield this.sm.on('did-update-context', this.handleDidUpdateContext.bind(this));
+            yield this.loadCalendars();
+            this.inclusiveCalendarIds = this.calendars
+                .filter((c) => c.availableTimeSlotBehavior === 'include')
+                .map((c) => c.id);
+        });
+    }
+    loadCalendars() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.calendars = yield this.events.loadCalendars();
+        });
+    }
+    handleWillUpdateContext(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = yield this.optionallyAskForUpdateRepeatingStrategy(event);
+            }
+            return {
+                shouldAllowUpdates: pass,
+            };
+        });
+    }
+    handleDidUpdateContext() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+                yield this.saveEvent(event);
+            }
+        });
+    }
+    saveEvent(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const cleaned = normalizeSchemaValues(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);
+            }
+        });
+    }
+    optionallyAskForUpdateRepeatingStrategy(event) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const cleaned = normalizeSchemaValues(calendarEventSchema, event, {});
+            if (((_a = cleaned.totalInRepeating) !== null && _a !== void 0 ? _a : 0) > 1) {
+                let strategy = yield 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;
+        });
+    }
+}

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