@sprucelabs/spruce-calendar-components 22.7.9 → 22.7.11

package/build/__tests__/support/SpyEventManager.d.ts

@@ -0,0 +1,42 @@
+import { CalendarEvent, CalendarToolBeltContext, UpdateCalendarToolBeltContextHandler } from '../../types/calendar.types';
+import CalendarEventManager, { CalendarEventManagerOptions } from '../../utilities/CalendarEventManager';
+import SpyRemoteEventStore from './SpyRemoteEventStore';
+import SpyRemotePreferencesStore from './SpyRemotePreferencesStore';
+export default class SpyEventManager extends CalendarEventManager {
+    updateContext?: UpdateCalendarToolBeltContextHandler<CalendarToolBeltContext>;
+    getShouldIgnoreNextContextUpdate(): boolean;
+    constructor(options: SpyEventManagerOptions);
+    getRemoteEventsStore(): SpyRemoteEventStore;
+    getStateMachine(): import("../../types/calendar.types").CalendarToolBeltStateMachine<CalendarToolBeltContext>;
+    getPreferences(): SpyRemotePreferencesStore;
+    silentlySetAllEvents(events: CalendarEvent[]): void;
+    silentlyMixinEvents(events: CalendarEvent[]): void;
+    silentlyAddEvent(event: CalendarEvent): void;
+    updateEventInContext(updates: Partial<CalendarEvent>): Promise<{
+        isBusy: boolean;
+        id: string;
+        target: import("@sprucelabs/spruce-core-schemas").SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEventTarget;
+        calendarId: string;
+        eventTypeSlug?: string | null | undefined;
+        startDateTimeMs: number;
+        isResizeable?: boolean | null | undefined;
+        style?: "draft" | "tentative" | "upcoming" | "unavailable" | "blocked" | "active" | "past" | "warn" | "critical" | null | undefined;
+        groupId?: string | null | undefined;
+        timeBlocks: import("@sprucelabs/spruce-core-schemas").SpruceSchemas.CalendarUtils.v2021_05_19.EventTimeBlock[];
+        repeats?: "weekly" | "monthly" | "daily" | null | undefined;
+        daysOfWeek?: ("sun" | "mon" | "tue" | "wed" | "thur" | "fri" | "sat")[] | null | undefined;
+        daysOfMonth?: ("1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | "11" | "12" | "13" | "14" | "15" | "16" | "17" | "18" | "19" | "20" | "21" | "22" | "23" | "24" | "25" | "26" | "27" | "28" | "29" | "30" | "31")[] | null | undefined;
+        repeatsUntil?: number | null | undefined;
+        occurrences?: number | null | undefined;
+        interval?: number | null | undefined;
+        nthOccurrences?: number[] | null | undefined;
+        activeUntilDate?: number | null | undefined;
+        exclusionDates?: import("@sprucelabs/spruce-core-schemas").SpruceSchemas.CalendarUtils.v2021_05_19.EventExclusionDate[] | null | undefined;
+        nthInRepeating?: number | null | undefined;
+        totalInRepeating?: number | null | undefined;
+        error?: Error | null | undefined;
+        isSelected?: boolean | null | undefined;
+        controller?: import("@sprucelabs/heartwood-view-controllers").CalendarEventViewController | null | undefined;
+    }>;
+}
+export declare type SpyEventManagerOptions = CalendarEventManagerOptions;

package/build/__tests__/support/SpyEventManager.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CalendarEventManager_1 = __importDefault(require("../../utilities/CalendarEventManager"));
+class SpyEventManager extends CalendarEventManager_1.default {
+    constructor(options) {
+        super(options);
+    }
+    getShouldIgnoreNextContextUpdate() {
+        return this.shouldIgnoreNextContextUpdate;
+    }
+    getRemoteEventsStore() {
+        return this.events;
+    }
+    getStateMachine() {
+        return this.sm;
+    }
+    getPreferences() {
+        return this.prefs;
+    }
+    silentlySetAllEvents(events) {
+        this.allEvents = events;
+    }
+    silentlyMixinEvents(events) {
+        this.allEvents = [...this.allEvents, ...events];
+    }
+    silentlyAddEvent(event) {
+        this.allEvents.push(event);
+    }
+    async updateEventInContext(updates) {
+        return super.updateEventInContext(updates);
+    }
+}
+exports.default = SpyEventManager;

package/build/__tests__/support/SpyPeopleManager.d.ts

@@ -0,0 +1,10 @@
+import CalendarPeopleManager, { PeopleManagerOptions, SetVisiblePeolpeOptions } from '../../utilities/CalendarPeopleManager';
+import { PersonMode } from '../../viewControllers/PersonSelectTool.vc';
+export default class SpyPeopleManager extends CalendarPeopleManager {
+    visiblePeopleIds?: string[];
+    peopleVisibilityMode?: PersonMode;
+    constructor(options: PeopleManagerOptions);
+    protected getVisiblePeopleIds(): string[];
+    getVisibilityMode(): PersonMode;
+    setVisiblePeopleIds(ids: string[], options?: SetVisiblePeolpeOptions): Promise<void>;
+}

package/build/__tests__/support/SpyPeopleManager.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CalendarPeopleManager_1 = __importDefault(require("../../utilities/CalendarPeopleManager"));
+class SpyPeopleManager extends CalendarPeopleManager_1.default {
+    constructor(options) {
+        super(options);
+    }
+    getVisiblePeopleIds() {
+        var _a;
+        return (_a = this.visiblePeopleIds) !== null && _a !== void 0 ? _a : super.getVisiblePeopleIds();
+    }
+    getVisibilityMode() {
+        var _a;
+        return (_a = this.peopleVisibilityMode) !== null && _a !== void 0 ? _a : super.getVisibilityMode();
+    }
+    async setVisiblePeopleIds(ids, options) {
+        return super.setVisiblePeopleIds(ids, options);
+    }
+}
+exports.default = SpyPeopleManager;

package/build/__tests__/support/SpyRemoteEventStore.d.ts

@@ -0,0 +1,18 @@
+import { MercuryClient } from '@sprucelabs/mercury-client';
+import { SpruceSchemas } from '@sprucelabs/spruce-core-schemas';
+import RemoteEventStoreImpl, { RemoteEventStoreOptions } from '../../stores/RemoteEventStore';
+import { Calendar, UpdateEvent } from '../../types/calendar.types';
+export default class SpyRemoteEventStore extends RemoteEventStoreImpl {
+    private calendars?;
+    lastPersistedEvent?: SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent;
+    constructor(options: Omit<RemoteEventStoreOptions, 'connectToApi'> & {
+        calendars?: Calendar[];
+        locationId?: string;
+        organizationId?: string;
+        client: MercuryClient;
+    });
+    setOrganizationId(id: string): void;
+    cancelEvent(_id: string): Promise<void>;
+    getCalendars(): Promise<SpruceSchemas.Calendar.v2021_05_19.Calendar[] | import("@sprucelabs/schema").SchemaStaticValues<SpruceSchemas.Calendar.v2021_05_19.CalendarSchema, false, import("@sprucelabs/schema").SchemaOptionalFieldNames<SpruceSchemas.Calendar.v2021_05_19.CalendarSchema>, import("@sprucelabs/schema").StaticSchemaAllValues<SpruceSchemas.Calendar.v2021_05_19.CalendarSchema, false>>[]>;
+    persist(event: UpdateEvent): Promise<SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent>;
+}

package/build/__tests__/support/SpyRemoteEventStore.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_utils_1 = require("@sprucelabs/test-utils");
+const RemoteEventStore_1 = __importDefault(require("../../stores/RemoteEventStore"));
+class SpyRemoteEventStore extends RemoteEventStore_1.default {
+    constructor(options) {
+        const { calendars, client, locationId, organizationId } = options;
+        super({ connectToApi: async () => client });
+        this.client = client;
+        this.calendars = calendars;
+        this.locationId = locationId !== null && locationId !== void 0 ? locationId : (0, test_utils_1.generateId)();
+        this.organizationId = organizationId !== null && organizationId !== void 0 ? organizationId : (0, test_utils_1.generateId)();
+    }
+    setOrganizationId(id) {
+        this.organizationId = id;
+    }
+    async cancelEvent(_id) { }
+    async getCalendars() {
+        var _a;
+        return (_a = this.calendars) !== null && _a !== void 0 ? _a : super.getCalendars();
+    }
+    async persist(event) {
+        const results = await super.persist(event);
+        this.lastPersistedEvent = results;
+        return results;
+    }
+}
+exports.default = SpyRemoteEventStore;

package/build/__tests__/support/SpyRemotePreferencesStore.d.ts

@@ -0,0 +1,9 @@
+import { MercuryClient } from '@sprucelabs/mercury-client';
+import RemotePreferencesStore from '../../stores/RemotePreferencesStore';
+export default class SpyRemotePreferencesStore extends RemotePreferencesStore {
+    constructor(options: {
+        client: MercuryClient;
+        visibleCalendarIds?: string[];
+    });
+    protected save(): Promise<void>;
+}

package/build/__tests__/support/SpyRemotePreferencesStore.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RemotePreferencesStore_1 = __importDefault(require("../../stores/RemotePreferencesStore"));
+class SpyRemotePreferencesStore extends RemotePreferencesStore_1.default {
+    constructor(options) {
+        const { visibleCalendarIds, client } = options;
+        super({ connectToApi: async () => client });
+        this.client = client;
+        this.isLoaded = true;
+        this.visibleCalendarIds = visibleCalendarIds;
+    }
+    async save() { }
+}
+exports.default = SpyRemotePreferencesStore;

package/build/__tests__/support/utilities/calendarAssert.d.ts

@@ -0,0 +1,13 @@
+import { CalendarEvent, SpruceSchemas, ViewController } from '@sprucelabs/heartwood-view-controllers';
+declare type Calendar = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.Calendar;
+declare type Event = SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent;
+declare const calendarAssert: {
+    rendersTotalEvents(vc: ViewController<Calendar>, expected: number): void;
+    hasEvent(vc: ViewController<Calendar>, lookup: Partial<Event>): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent;
+    eventsAreEqual(actual: Event[], expected: Event[]): void;
+    includesInEvent(events: Event[], lookup: Partial<Event>): SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent;
+    eventIsDuration(event: Event, expectedDuration: number): void;
+    eventsFallOnDows(events: CalendarEvent[], expectedDows: string[]): void;
+    eventEquals(actual: Partial<CalendarEvent> | undefined | null, expected: Partial<CalendarEvent> | undefined | null): void;
+};
+export default calendarAssert;

package/build/__tests__/support/utilities/calendarAssert.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const calendar_utils_1 = require("@sprucelabs/calendar-utils");
+const heartwood_view_controllers_1 = require("@sprucelabs/heartwood-view-controllers");
+const test_1 = require("@sprucelabs/test");
+const just_clone_1 = __importDefault(require("just-clone"));
+const calendarAssert = {
+    rendersTotalEvents(vc, expected) {
+        const model = heartwood_view_controllers_1.renderUtil.render(vc);
+        test_1.assert.isLength(model.events, expected);
+    },
+    hasEvent(vc, lookup) {
+        const { events } = heartwood_view_controllers_1.renderUtil.render(vc);
+        return this.includesInEvent(events, lookup);
+    },
+    eventsAreEqual(actual, expected) {
+        function sort(a, b) {
+            return a.id > b.id ? 1 : -1;
+        }
+        actual.sort(sort);
+        expected.sort(sort);
+        test_1.assert.isEqualDeep(actual, expected);
+    },
+    includesInEvent(events, lookup) {
+        const match = events.find((e) => {
+            try {
+                test_1.assert.doesInclude(e, lookup);
+                return e;
+                // eslint-disable-next-line no-empty
+            }
+            catch (_a) { }
+            return null;
+        });
+        test_1.assert.isTruthy(match, `I could not find an event that matched:\n\n${test_1.assertUtil.stringify(lookup)}`);
+        return match;
+    },
+    eventIsDuration(event, expectedDuration) {
+        const duration = event.timeBlocks.reduce((minutes, timeBlock) => {
+            minutes += timeBlock.durationMinutes;
+            return minutes;
+        }, 0);
+        test_1.assert.isEqual(duration, expectedDuration);
+    },
+    eventsFallOnDows(events, expectedDows) {
+        const remaining = [...expectedDows];
+        for (const event of events) {
+            const dow = calendar_utils_1.dateUtil.getDayOfWeek(event.startDateTimeMs);
+            const idx = remaining.indexOf(dow);
+            if (idx === -1) {
+                test_1.assert.fail(`Checking days of week and got ${dow} but it wasn't in the array of expected dows.`);
+            }
+            remaining.splice(idx, 1);
+        }
+        if (remaining.length > 0) {
+            test_1.assert.fail(`Didn't find the following days of week in events:\n\n${test_1.assertUtil.stringify(remaining)}`);
+        }
+    },
+    eventEquals(actual, expected) {
+        var _a, _b, _c;
+        test_1.assert.isTruthy(actual, 'Event is missing');
+        test_1.assert.isTruthy(expected, 'Event is missing');
+        test_1.assert.isEqual(actual.startDateTimeMs, expected.startDateTimeMs, 'startDateTimeMs does not match');
+        test_1.assert.isEqual((_a = actual.isBusy) !== null && _a !== void 0 ? _a : false, (_b = expected.isBusy) !== null && _b !== void 0 ? _b : false, `isBusy does not match, needs to be '${(_c = expected.isBusy) !== null && _c !== void 0 ? _c : false}'`);
+        const cleanedActual = (0, just_clone_1.default)(actual);
+        const cleanedExpected = (0, just_clone_1.default)(expected);
+        cleanEvent(cleanedActual);
+        cleanEvent(cleanedExpected);
+        test_1.assert.isEqualDeep(cleanedActual, cleanedExpected, 'Your event did not equal what I expected!');
+    },
+};
+function cleanEvent(obj, propsToIgnore = [
+    'isSelected',
+    'source',
+    'dateCreated',
+    'isBusy',
+    'controller',
+]) {
+    for (const prop in obj) {
+        const value = obj[prop];
+        if (propsToIgnore.indexOf(prop) > -1 ||
+            value === null ||
+            typeof value === 'undefined') {
+            delete obj[prop];
+        }
+        else if (typeof value === 'object') {
+            cleanEvent(value);
+        }
+    }
+}
+exports.default = calendarAssert;

package/build/__tests__/support/utilities/calendarSkillAssert.d.ts

@@ -0,0 +1,40 @@
+import { ToolBeltState, AbstractCalendarEventViewController, ToolBeltStateMachine, SpruceSchemas } from '@sprucelabs/heartwood-view-controllers';
+import { MercuryClient } from '@sprucelabs/mercury-client';
+import { ViewFixture } from '@sprucelabs/spruce-test-fixtures';
+import AbstractCalendarEventToolBeltState from '../../../toolBelt/states/AbstractCalendarEventToolBeltState';
+export interface AssertRemoteToolsOptions {
+    client: MercuryClient;
+    state: ToolBeltState;
+    views: ViewFixture;
+}
+interface TypeWithVcId {
+    typeSlug: string;
+    vcId: string;
+}
+export declare type AssertTypeSlug = string | TypeWithVcId;
+declare const calendarSkillAssert: {
+    createdEventTypes: SpruceSchemas.Calendar.v2021_05_19.CalendarEventType[];
+    createdCalendars: SpruceSchemas.Calendar.v2021_05_19.Calendar[];
+    beforeEach(views: ViewFixture): Promise<void>;
+    createsCalendarOnInstall(calendarSlug: string, client: MercuryClient, typeSlugs?: string[]): Promise<void>;
+    createsCalendarsWithMultipleInstalls(calendarSlug: string, client: MercuryClient): Promise<void>;
+    createsEventTypesOnBoot(types: AssertTypeSlug[], client: MercuryClient, boot: () => Promise<any>): Promise<void>;
+    createsEventTypesWithMultipleBoots(types: AssertTypeSlug[], client: MercuryClient, boot: () => Promise<any>): Promise<void>;
+    isValidEventViewController(options: {
+        views: ViewFixture;
+        CalendarEventClass: typeof AbstractCalendarEventViewController;
+        ToolBeltStateClass: any;
+    }): void;
+    stateFetchesAndRendersRemoteTools(options: AssertRemoteToolsOptions): Promise<{
+        toolId: string;
+        Class: any;
+    }[]>;
+    toolBeltStateProperlyInheritsAbstractToolBeltState(stateMachine: ToolBeltStateMachine, state: AbstractCalendarEventToolBeltState): Promise<void>;
+    toolBeltStateAddsTool(options: {
+        state: AbstractCalendarEventToolBeltState;
+        toolId: string;
+        views: ViewFixture;
+        Class?: any;
+    }): Promise<SpruceSchemas.HeartwoodViewControllers.v2021_02_11.ToolBeltTool>;
+};
+export default calendarSkillAssert;