@sprucelabs/spruce-calendar-components 28.3.103 → 29.0.0

package/build/calendar/CalendarEventManager.js

@@ -1,15 +1,4 @@
 "use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -22,16 +11,32 @@ const draftGenerator_1 = __importDefault(require("../utilities/draftGenerator"))
 const calculateCalendarEventDifferences_1 = __importDefault(require("./calculateCalendarEventDifferences"));
 const CalendarPersister_1 = __importDefault(require("./CalendarPersister"));
 class CalendarEventManager {
+    static shouldBatchEvents = false;
+    calendarVc;
+    allEvents = [];
+    inclusiveCalendarIds = [];
+    events;
+    eventTypes;
+    remoteVc;
+    hasVcForEventTypeBeenLoaded = {};
+    sm;
+    shouldIgnoreNextContextUpdate = false;
+    askForUpdateStrategy;
+    dateToUpdate;
+    shouldUpdateAllEventsGoingForward;
+    prefs;
+    calendars = [];
+    isLoaded = false;
+    updateContext;
+    updateOperations = [];
+    isRunningUpdateQueue = false;
+    updateQueuePromise;
+    persister;
+    hasPendingContextChanges = false;
+    //@ts-ignore
+    loadEventsStartTimeMs;
+    activeChunk;
     constructor(options) {
-        this.allEvents = [];
-        this.inclusiveCalendarIds = [];
-        this.hasVcForEventTypeBeenLoaded = {};
-        this.shouldIgnoreNextContextUpdate = false;
-        this.calendars = [];
-        this.isLoaded = false;
-        this.updateOperations = [];
-        this.isRunningUpdateQueue = false;
-        this.hasPendingContextChanges = false;
         const { calendarVc, events, remoteVc, sm, askForUpdateStrategy, preferences, } = (0, schema_1.assertOptions)(options, [
             'calendarVc',
             'events',
@@ -58,13 +63,12 @@ class CalendarEventManager {
         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);
+        return (this.prefs.getVisibleCalendarIds() ??
+            this.calendars.map((c) => c.id));
     }
     async handleStreamEvents(options) {
-        var _a;
         const { events, chunkingId } = options;
-        const { id, startDate, endDate } = (_a = this.activeChunk) !== null && _a !== void 0 ? _a : {};
+        const { id, startDate, endDate } = this.activeChunk ?? {};
         if (id !== chunkingId || !startDate || !endDate) {
             return;
         }
@@ -86,8 +90,7 @@ class CalendarEventManager {
         this.calendarVc.setShifts([...shifts]);
     }
     doShiftsMatchWhatIsInCalendar(shifts) {
-        var _a;
-        const currentShifts = this.generateShiftKeys((_a = this.calendarVc.getShifts()) !== null && _a !== void 0 ? _a : []);
+        const currentShifts = this.generateShiftKeys(this.calendarVc.getShifts() ?? []);
         const newShifts = this.generateShiftKeys(shifts);
         const areShiftsTheSame = newShifts === currentShifts;
         return areShiftsTheSame;
@@ -133,7 +136,7 @@ class CalendarEventManager {
         return this.persister.persist(event);
     }
     addEvent(event) {
-        this.allEvents.push(Object.assign({}, event));
+        this.allEvents.push({ ...event });
         this.calendarVc.addEvent(event);
     }
     addEvents(events) {
@@ -141,19 +144,24 @@ class CalendarEventManager {
         this.calendarVc.mixinEvents(events);
     }
     async silentlySwapEvent(oldId, event) {
-        var _a;
         const events = this.getEvents().filter((e) => e.id !== oldId);
         this.allEvents = [...events, event];
-        if (((_a = this.sm.getContext().event) === null || _a === void 0 ? void 0 : _a.id) === oldId) {
+        if (this.sm.getContext().event?.id === oldId) {
             await this.updateEventInContext(event);
         }
     }
     async handleDropEvent(id, updates) {
-        const event = Object.assign(Object.assign({}, this.calendarVc.getEvent(id)), updates);
+        const event = {
+            ...this.calendarVc.getEvent(id),
+            ...updates,
+        };
         const { pass, dateToUpdate, shouldUpdateAllEventsGoingForward } = await this.optionallyAskForUpdateRepeatingStrategy(event);
         if (pass) {
-            this.updateEvent(id, Object.assign(Object.assign({}, event), { dateToUpdate,
-                shouldUpdateAllEventsGoingForward }));
+            this.updateEvent(id, {
+                ...event,
+                dateToUpdate,
+                shouldUpdateAllEventsGoingForward,
+            });
         }
         return pass;
     }
@@ -164,9 +172,8 @@ class CalendarEventManager {
         }
     }
     async reset() {
-        var _a;
         await this.setEventInContext(undefined);
-        (_a = this.events) === null || _a === void 0 ? void 0 : _a.clearCalendarId();
+        this.events?.clearCalendarId();
     }
     async restoreEventToDraftOnStateLoadError() {
         const updated = await this.updateEventInContext({
@@ -180,8 +187,7 @@ class CalendarEventManager {
         return this.visibleCalendarIds;
     }
     async cancelEvent(id, options) {
-        var _a;
-        const { shouldPersist = true } = options !== null && options !== void 0 ? options : {};
+        const { shouldPersist = true } = options ?? {};
         const event = this.calendarVc.getEvent(id);
         if (shouldPersist) {
             const { pass } = await this.optionallyAskForUpdateRepeatingStrategy(event, 'cancel');
@@ -202,8 +208,8 @@ class CalendarEventManager {
             this.refreshShifts();
         }
         catch (err) {
-            console.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
-            this.calendarVc.addEvent(Object.assign(Object.assign({}, event), { error: err }));
+            console.error(err.stack ?? err.message);
+            this.calendarVc.addEvent({ ...event, error: err });
         }
         this.clearRepeatingStrategyOptions();
     }
@@ -236,7 +242,6 @@ class CalendarEventManager {
         await this.updateQueuePromise;
     }
     async runUpdateQueue() {
-        var _a;
         this.isRunningUpdateQueue = true;
         let next;
         const savedEvents = [];
@@ -244,23 +249,25 @@ class CalendarEventManager {
             const e = await next.execute();
             savedEvents.push(e);
         }
-        const currentId = (_a = this.sm.getContext().event) === null || _a === void 0 ? void 0 : _a.id;
+        const currentId = this.sm.getContext().event?.id;
         savedEvents.reverse();
         const eventMatching = savedEvents.find((e) => e.id === currentId);
-        if (!this.hasPendingContextChanges && currentId === (eventMatching === null || eventMatching === void 0 ? void 0 : eventMatching.id)) {
+        if (!this.hasPendingContextChanges && currentId === eventMatching?.id) {
             await this.updateEventInContext(eventMatching);
         }
         this.isRunningUpdateQueue = false;
     }
     async _updateEvent(id, updates) {
-        var _a;
-        let { shouldPersist = true, dateToUpdate, shouldUpdateAllEventsGoingForward } = updates, rest = __rest(updates, ["shouldPersist", "dateToUpdate", "shouldUpdateAllEventsGoingForward"]);
+        let { shouldPersist = true, dateToUpdate, shouldUpdateAllEventsGoingForward, ...rest } = updates;
         const { isTheSame, isTheSameWithoutBusy, match: originalEvent, } = this.calculateDifferences(id, updates);
         if (isTheSame) {
             return originalEvent;
         }
         const idx = this.allEvents.findIndex((e) => e.id === id);
-        let updatedEvent = Object.assign(Object.assign({}, originalEvent), rest);
+        let updatedEvent = {
+            ...originalEvent,
+            ...rest,
+        };
         if (typeof shouldUpdateAllEventsGoingForward === 'undefined') {
             const { pass, dateToUpdate: date, shouldUpdateAllEventsGoingForward: should, } = await this.optionallyAskForUpdateRepeatingStrategy(updatedEvent);
             dateToUpdate = date;
@@ -278,7 +285,10 @@ class CalendarEventManager {
         }
         try {
             const isGoodToPersist = shouldPersist && !isTheSameWithoutBusy;
-            this.calendarVc.updateEvent(id, Object.assign(Object.assign({}, rest), { shouldPersist: false }));
+            this.calendarVc.updateEvent(id, {
+                ...rest,
+                shouldPersist: false,
+            });
             if (isGoodToPersist) {
                 const response = await this.persister.persist(updatedEvent);
                 if (response) {
@@ -287,7 +297,7 @@ class CalendarEventManager {
             }
         }
         catch (err) {
-            console.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+            console.error(err.stack ?? err.message);
             return originalEvent;
         }
         this.allEvents[idx] = updatedEvent;
@@ -319,7 +329,10 @@ class CalendarEventManager {
                 startDate,
                 endDate,
             };
-            await this.events.sendSchedules(Object.assign(Object.assign({}, scheduleOptions), { chunkingId: this.activeChunk.id }));
+            await this.events.sendSchedules({
+                ...scheduleOptions,
+                chunkingId: this.activeChunk.id,
+            });
             return;
         }
         const events = await this.events.getSchedules(scheduleOptions);
@@ -334,9 +347,8 @@ class CalendarEventManager {
                 this.eventTypes = await this.events.getEventTypes();
             }
             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) {
+                const type = this.eventTypes?.find((t) => t.slug === e.eventTypeSlug);
+                if (type?.viewControllerId) {
                     await this.setupVcForEventType(type.viewControllerId, type.slug);
                 }
             }));
@@ -376,15 +388,18 @@ class CalendarEventManager {
     }
     async updateEventInContext(updates) {
         const { event } = this.sm.getContext();
-        const updated = Object.assign(Object.assign(Object.assign({}, event), updates), { isBusy: false });
+        const updated = {
+            ...event,
+            ...updates,
+            isBusy: false,
+        };
         await this.setEventInContext(updated);
         return updated;
     }
     async setEventInContext(newEvent, options) {
-        var _a;
         this.shouldIgnoreNextContextUpdate =
-            (options === null || options === void 0 ? void 0 : options.shouldHandleDidUpdateContext) !== false;
-        const didTrigger = await ((_a = this.updateContext) !== null && _a !== void 0 ? _a : this.sm.updateContext.bind(this.sm))({
+            options?.shouldHandleDidUpdateContext !== false;
+        const didTrigger = await (this.updateContext ?? this.sm.updateContext.bind(this.sm))({
             event: newEvent,
         });
         if (!didTrigger) {
@@ -401,7 +416,7 @@ class CalendarEventManager {
         const lastSelected = this.getSelectedEvent();
         const event = this.calendarVc.getEvent(eventId);
         await this.calendarVc.selectEvent(event.id);
-        if ((lastSelected === null || lastSelected === void 0 ? void 0 : lastSelected.id) !== event.id) {
+        if (lastSelected?.id !== event.id) {
             await this.setEventInContext(event);
         }
     }
@@ -434,8 +449,8 @@ class CalendarEventManager {
         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) &&
+        if (event?.id &&
+            originalEvent?.id === event?.id &&
             !this.shouldIgnoreNextContextUpdate) {
             const strat = await this.optionallyAskForUpdateRepeatingStrategy(event);
             pass = strat.pass;
@@ -462,17 +477,21 @@ class CalendarEventManager {
             return;
         }
         const { event } = this.sm.getContext();
-        if (event === null || event === void 0 ? void 0 : event.id) {
+        if (event?.id) {
             this.hasPendingContextChanges = false;
             await this.saveEvent(event);
         }
     }
     async saveEvent(event) {
         try {
-            const cleaned = (0, schema_1.normalizeSchemaValues)(heartwood_view_controllers_1.calendarEventSchema, Object.assign({}, event), {
+            const cleaned = (0, schema_1.normalizeSchemaValues)(heartwood_view_controllers_1.calendarEventSchema, { ...event }, {
                 shouldIncludeNullAndUndefinedFields: true,
             });
-            this.updateEvent(event.id, Object.assign(Object.assign({}, cleaned), { dateToUpdate: this.dateToUpdate, shouldUpdateAllEventsGoingForward: this.shouldUpdateAllEventsGoingForward }));
+            this.updateEvent(event.id, {
+                ...cleaned,
+                dateToUpdate: this.dateToUpdate,
+                shouldUpdateAllEventsGoingForward: this.shouldUpdateAllEventsGoingForward,
+            });
             this.clearRepeatingStrategyOptions();
         }
         catch (err) {
@@ -490,17 +509,15 @@ class CalendarEventManager {
         return !!this.allEvents.find((e) => e.id === id);
     }
     getLastChunkingId() {
-        var _a;
-        return (_a = this.activeChunk) === null || _a === void 0 ? void 0 : _a.id;
+        return this.activeChunk?.id;
     }
     async optionallyAskForUpdateRepeatingStrategy(event, action = 'update') {
-        var _a;
         if (!event.id) {
             return { pass: true };
         }
         let dateToUpdate = undefined;
         let shouldUpdateAllEventsGoingForward = undefined;
-        if (((_a = event.totalInRepeating) !== null && _a !== void 0 ? _a : 0) > 1) {
+        if ((event.totalInRepeating ?? 0) > 1) {
             const cleaned = (0, schema_1.normalizeSchemaValues)(heartwood_view_controllers_1.calendarEventSchema, event, {
                 shouldIncludeNullAndUndefinedFields: false,
             });
@@ -521,14 +538,17 @@ class CalendarEventManager {
                 shouldUpdateAllEventsGoingForward = false;
             }
             this.dateToUpdate = dateToUpdate;
-            this.shouldUpdateAllEventsGoingForward = shouldUpdateAllEventsGoingForward;
+            this.shouldUpdateAllEventsGoingForward =
+                shouldUpdateAllEventsGoingForward;
         }
         return { pass: true, dateToUpdate, shouldUpdateAllEventsGoingForward };
     }
 }
-CalendarEventManager.shouldBatchEvents = false;
 exports.default = CalendarEventManager;
 class UpdateOperation {
+    id;
+    updates;
+    onComplete;
     constructor(options) {
         const { id, updates, onComplete } = options;
         this.id = id;

package/build/calendar/CalendarPeopleManager.js

@@ -9,18 +9,25 @@ 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 {
+    connectToApi;
+    prefs;
+    client;
+    loggedInPerson;
+    locationId;
+    organizationId;
+    team = [];
+    getVisibleEvents;
     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 : {};
+        const { loggedInPerson, organizationId, locationId } = options ?? {};
         this.client = await this.connectToApi();
-        this.loggedInPerson = loggedInPerson !== null && loggedInPerson !== void 0 ? loggedInPerson : undefined;
+        this.loggedInPerson = loggedInPerson ?? undefined;
         this.organizationId = organizationId;
         this.locationId = locationId;
         await this.loadTeam();
@@ -45,17 +52,15 @@ class CalendarPeopleManager extends mercury_event_emitter_1.AbstractEventEmitter
             .map((i) => {
             try {
                 return this.teammateById(i);
-                // eslint-disable-next-line no-empty
             }
-            catch (_a) { }
+            catch { }
             return null;
         })
             .filter((t) => !!t);
         return people;
     }
     teammateById(id) {
-        var _a;
-        const teammate = (_a = this.team) === null || _a === void 0 ? void 0 : _a.find((t) => t.id === id);
+        const teammate = this.team?.find((t) => t.id === id);
         if (!teammate) {
             throw new SpruceError_1.default({
                 code: 'PERSON_NOT_FOUND',
@@ -71,18 +76,16 @@ class CalendarPeopleManager extends mercury_event_emitter_1.AbstractEventEmitter
         return this.loggedInPerson;
     }
     getVisiblePeopleIds() {
-        var _a;
         if (this.getVisibilityMode() === 'working') {
             return this.getWorkingPeopleIds();
         }
-        return (_a = this.getSavedVisiblePeopleIds()) !== null && _a !== void 0 ? _a : [];
+        return this.getSavedVisiblePeopleIds() ?? [];
     }
     getSavedVisiblePeopleIds() {
         return this.prefs.getVisiblePeopleIds();
     }
     getVisibilityMode() {
-        var _a;
-        return (_a = this.prefs.getVisiblePeopleMode()) !== null && _a !== void 0 ? _a : 'me';
+        return this.prefs.getVisiblePeopleMode() ?? 'me';
     }
     async setVisibilityMode(mode) {
         if (this.getVisibilityMode() === mode) {
@@ -118,18 +121,16 @@ class CalendarPeopleManager extends mercury_event_emitter_1.AbstractEventEmitter
             .map((id) => {
             try {
                 return this.teammateById(id);
-                // eslint-disable-next-line no-empty
             }
-            catch (_a) { }
+            catch { }
             return false;
         })
             .filter((p) => !!p);
     }
     async setVisiblePeopleIds(visible, options) {
-        var _a;
-        const { shouldForceEmitDidChange } = options !== null && options !== void 0 ? options : {};
+        const { shouldForceEmitDidChange } = options ?? {};
         const newVisibile = visible.filter((id, idx) => visible.indexOf(id) === idx);
-        const oldVisible = (_a = this.getSavedVisiblePeopleIds()) !== null && _a !== void 0 ? _a : [];
+        const oldVisible = this.getSavedVisiblePeopleIds() ?? [];
         const newKey = newVisibile.join('');
         const oldKey = oldVisible.join('');
         const didChange = newKey !== oldKey;

package/build/calendar/CalendarPersister.d.ts

@@ -19,9 +19,9 @@ export default class CalendarPersister {
     cancelEvent(id: string, options?: CancelEventRecurringOptions): Promise<void>;
 }
 type DraftHandlerCalendar = Pick<CalendarViewController, 'hasEvent' | 'updateEvent' | 'swapEvent' | 'removeEvent'>;
-export type CalendarPersisterOptions = {
+export interface CalendarPersisterOptions {
     calendarVc: DraftHandlerCalendar;
     events?: RemoteEventStore;
     onEventSwapped?: EventSwappedHandler;
-};
+}
 export {};

package/build/calendar/CalendarPersister.js

@@ -1,16 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class CalendarPersister {
+    static Class;
+    activelyPersisting = {};
+    persistPromise;
+    events;
+    lastSwappedId;
+    calendarVc;
+    eventSwappedHandler;
     constructor(options) {
-        this.activelyPersisting = {};
         const { events, calendarVc, onEventSwapped } = options;
         this.events = events;
         this.calendarVc = calendarVc;
         this.eventSwappedHandler = onEventSwapped;
     }
     static Persister(options) {
-        var _a;
-        return new ((_a = this.Class) !== null && _a !== void 0 ? _a : CalendarPersister)(options);
+        return new (this.Class ?? CalendarPersister)(options);
     }
     async persist(event) {
         this.persistPromise = this._persist(event);
@@ -26,7 +31,6 @@ class CalendarPersister {
         return this.events;
     }
     async _persist(event) {
-        var _a, _b;
         let updated = event;
         const id = updated.id;
         try {
@@ -40,7 +44,9 @@ class CalendarPersister {
                 isBusy: true,
                 shouldPersist: false,
             });
-            const saved = await ((_a = this.events) === null || _a === void 0 ? void 0 : _a.persist(Object.assign({}, event)));
+            const saved = await this.events?.persist({
+                ...event,
+            });
             this.activelyPersisting[id]--;
             if (!saved) {
                 return undefined;
@@ -54,7 +60,7 @@ class CalendarPersister {
                     await this.calendarVc.swapEvent(event, saved);
                 }
                 if (this.activelyPersisting[id] === 0) {
-                    await ((_b = this.eventSwappedHandler) === null || _b === void 0 ? void 0 : _b.call(this, event, saved));
+                    await this.eventSwappedHandler?.(event, saved);
                 }
             }
             else {
@@ -78,8 +84,7 @@ class CalendarPersister {
         return event;
     }
     async cancelEvent(id, options) {
-        var _a;
-        await ((_a = this.events) === null || _a === void 0 ? void 0 : _a.cancelEvent(id, options));
+        await this.events?.cancelEvent(id, options);
     }
 }
 exports.default = CalendarPersister;

package/build/calendar/calculateCalendarEventDifferences.js

@@ -2,11 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const spruce_skill_utils_1 = require("@sprucelabs/spruce-skill-utils");
 function calculateCalendarEventDifferences(event, updates) {
-    const updated = Object.assign(Object.assign({}, event), updates);
+    const updated = {
+        ...event,
+        ...updates,
+    };
     const isTheSame = (0, spruce_skill_utils_1.isEqual)(event, updated);
-    const updatesWithoutBusy = Object.assign({}, updated);
+    const updatesWithoutBusy = { ...updated };
     delete updatesWithoutBusy.isBusy;
-    const matchWithoutBusy = Object.assign({}, event);
+    const matchWithoutBusy = { ...event };
     delete matchWithoutBusy.isBusy;
     const isTheSameWithoutBusy = (0, spruce_skill_utils_1.isEqual)(matchWithoutBusy, updatesWithoutBusy);
     return { isTheSame, isTheSameWithoutBusy };

package/build/constants.js

@@ -1,9 +1,8 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UPDATE_STRATEGY_ALL = exports.UPDATE_STRATEGY_THIS_AND_ALL_GOING_FORWARD = exports.UPDATE_STRATEGY_SPECIFIC_DATES = exports.MAX_GET_SCHEDULE_DAYS = void 0;
 require('dotenv').config();
-exports.MAX_GET_SCHEDULE_DAYS = parseInt((_a = process.env.MAX_GETSCHEDULE_DAYS) !== null && _a !== void 0 ? _a : '365');
+exports.MAX_GET_SCHEDULE_DAYS = parseInt(process.env.MAX_GETSCHEDULE_DAYS ?? '365');
 exports.UPDATE_STRATEGY_SPECIFIC_DATES = 'only-this-one';
 exports.UPDATE_STRATEGY_THIS_AND_ALL_GOING_FORWARD = 'all-going-forward';
 exports.UPDATE_STRATEGY_ALL = 'all';

package/build/errors/SpruceError.d.ts

@@ -1,5 +1,5 @@
 import AbstractSpruceError from '@sprucelabs/error';
-import ErrorOptions from "./../.spruce/errors/options.types";
+import ErrorOptions from './../.spruce/errors/options.types';
 export default class SpruceError extends AbstractSpruceError<ErrorOptions> {
     friendlyMessage(): string;
 }

package/build/errors/SpruceError.js

@@ -8,7 +8,7 @@ class SpruceError extends error_1.default {
     friendlyMessage() {
         const { options } = this;
         let message;
-        switch (options === null || options === void 0 ? void 0 : options.code) {
+        switch (options?.code) {
             case 'CALENDAR_NOT_FOUND':
                 message = 'I could not find that calendar!';
                 break;

package/build/esm/.spruce/errors/errors.types.d.ts

@@ -24,7 +24,7 @@ export declare namespace SpruceErrors.Calendar {
 }
 export declare namespace SpruceErrors.Calendar {
     interface RecordNotFound {
-        'parameters': string[];
+        parameters: string[];
     }
     interface RecordNotFoundSchema extends SpruceSchema.Schema {
         id: 'recordNotFound';
@@ -32,7 +32,7 @@ export declare namespace SpruceErrors.Calendar {
         name: 'record not found';
         fields: {
             /** . */
-            'parameters': {
+            parameters: {
                 type: 'text';
                 isRequired: true;
                 isArray: true;
@@ -44,7 +44,7 @@ export declare namespace SpruceErrors.Calendar {
 }
 export declare namespace SpruceErrors.Calendar {
     interface PersonNotFound {
-        'personId': string;
+        personId: string;
     }
     interface PersonNotFoundSchema extends SpruceSchema.Schema {
         id: 'personNotFound';
@@ -52,7 +52,7 @@ export declare namespace SpruceErrors.Calendar {
         name: 'Person not found';
         fields: {
             /** . */
-            'personId': {
+            personId: {
                 type: 'id';
                 isRequired: true;
                 options: undefined;
@@ -63,7 +63,7 @@ export declare namespace SpruceErrors.Calendar {
 }
 export declare namespace SpruceErrors.Calendar {
     interface EventNotFound {
-        'id': string;
+        id: string;
     }
     interface EventNotFoundSchema extends SpruceSchema.Schema {
         id: 'eventNotFound';
@@ -71,7 +71,7 @@ export declare namespace SpruceErrors.Calendar {
         name: 'Event Not Found';
         fields: {
             /** . */
-            'id': {
+            id: {
                 type: 'id';
                 isRequired: true;
                 options: undefined;
@@ -104,7 +104,7 @@ export declare namespace SpruceErrors.Calendar {
 }
 export declare namespace SpruceErrors.Calendar {
     interface CalendarToolInterface {
-        'vcId': string;
+        vcId: string;
     }
     interface CalendarToolInterfaceSchema extends SpruceSchema.Schema {
         id: 'calendarToolInterface';
@@ -112,7 +112,7 @@ export declare namespace SpruceErrors.Calendar {
         name: 'Calendar tool interface';
         fields: {
             /** . */
-            'vcId': {
+            vcId: {
                 type: 'id';
                 isRequired: true;
                 options: undefined;
@@ -123,8 +123,8 @@ export declare namespace SpruceErrors.Calendar {
 }
 export declare namespace SpruceErrors.Calendar {
     interface CalendarNotFound {
-        'calendarIds'?: string[] | undefined | null;
-        'calendarSlugs'?: string[] | undefined | null;
+        calendarIds?: string[] | undefined | null;
+        calendarSlugs?: string[] | undefined | null;
     }
     interface CalendarNotFoundSchema extends SpruceSchema.Schema {
         id: 'calendarNotFound';
@@ -132,13 +132,13 @@ export declare namespace SpruceErrors.Calendar {
         name: 'calendar not found';
         fields: {
             /** . */
-            'calendarIds': {
+            calendarIds: {
                 type: 'text';
                 isArray: true;
                 options: undefined;
             };
             /** . */
-            'calendarSlugs': {
+            calendarSlugs: {
                 type: 'text';
                 isArray: true;
                 options: undefined;

package/build/esm/.spruce/errors/errors.types.js

@@ -1,3 +1 @@
-/* eslint-disable @typescript-eslint/no-namespace */
-/* eslint-disable no-redeclare */
 export {};

package/build/esm/.spruce/errors/options.types.d.ts

@@ -1,5 +1,5 @@
-import { SpruceErrors } from "./errors.types";
-import { ErrorOptions as ISpruceErrorOptions } from "@sprucelabs/error";
+import { ErrorOptions as ISpruceErrorOptions } from '@sprucelabs/error';
+import { SpruceErrors } from './errors.types';
 export interface ValidatorNotInitializedErrorOptions extends SpruceErrors.Calendar.ValidatorNotInitialized, ISpruceErrorOptions {
     code: 'VALIDATOR_NOT_INITIALIZED';
 }