@sprucelabs/spruce-calendar-components 22.7.11 → 22.7.12

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

@@ -0,0 +1,39 @@
+import { SpruceSchemas } from '@sprucelabs/calendar-utils';
+import { ToolBeltViewController } from '@sprucelabs/heartwood-view-controllers';
+import { ViewFixture } from '@sprucelabs/spruce-test-fixtures';
+import { GetScheduleOptions, RemoteEventStore } from '../../stores/RemoteEventStore';
+import { CalendarToolBeltStateMachine, UpdateEvent } from '../../types/calendar.types';
+import CalendarViewController from '../../viewControllers/Calendar.vc';
+import SpyEventManager from './SpyEventManager';
+export default class CalendarToolBeltStateMachineTestFactory {
+    static StateMachine(views: ViewFixture): Promise<{
+        stateMachine: CalendarToolBeltStateMachine;
+        toolBeltVc: ToolBeltViewController;
+        calendarVc: CalendarViewController;
+        events: SpyEventManager;
+    }>;
+}
+declare module '@sprucelabs/heartwood-view-controllers/build/types/heartwood.types' {
+    interface ViewControllerMap {
+        'calendar.calendar': CalendarViewController;
+    }
+    interface ViewControllerOptionsMap {
+        'calendar.calendar': ConstructorParameters<typeof CalendarViewController>[0];
+    }
+}
+export declare class FakeRemoteEventStore implements RemoteEventStore {
+    lastPersistedEvent?: SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent;
+    load(_options: {
+        organizationId: string;
+        locationId: string;
+    }): Promise<void>;
+    persist(event: UpdateEvent): Promise<SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent>;
+    setCalendarId(_id: string): void;
+    clearCalendarId(): void;
+    getCalendarId(): string | undefined;
+    waitForPendingSaves(): Promise<void>;
+    cancelEvent(_id: string): Promise<void>;
+    getSchedules(_options: GetScheduleOptions): Promise<SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent[]>;
+    getEventTypes(): Promise<SpruceSchemas.Calendar.v2021_05_19.CalendarEventType[]>;
+    getCalendars(): Promise<SpruceSchemas.Calendar.v2021_05_19.Calendar[]>;
+}

package/build/__tests__/support/CalendarToolBeltStateMachineTestFactory.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FakeRemoteEventStore = void 0;
+const calendar_utils_1 = require("@sprucelabs/calendar-utils");
+const heartwood_view_controllers_1 = require("@sprucelabs/heartwood-view-controllers");
+const spruce_test_fixtures_1 = require("@sprucelabs/spruce-test-fixtures");
+const test_utils_1 = require("@sprucelabs/test-utils");
+const RemotePreferencesStore_1 = __importDefault(require("../../stores/RemotePreferencesStore"));
+const draftGenerator_1 = __importDefault(require("../../utilities/draftGenerator"));
+const Calendar_vc_1 = __importDefault(require("../../viewControllers/Calendar.vc"));
+const SpyEventManager_1 = __importDefault(require("./SpyEventManager"));
+const SpyPeopleManager_1 = __importDefault(require("./SpyPeopleManager"));
+class CalendarToolBeltStateMachineTestFactory {
+    static async StateMachine(views) {
+        const factory = views.getFactory();
+        if (!factory.hasController('calendar.calendar')) {
+            factory.mixinControllers({
+                //@ts-ignore
+                'calendar.calendar': Calendar_vc_1.default,
+            });
+        }
+        const toolBeltVc = views.Controller('toolBelt', {});
+        const event = heartwood_view_controllers_1.calendarSeeder.generateEventValues();
+        const calendarVc = views.Controller('calendar.calendar', {
+            onAddDraftEvent: () => { },
+            onEventSwapped(draft, saved) {
+                return events.silentlySwapEvent(draft.id, saved);
+            },
+        });
+        calendarVc.addEvent(event);
+        const sm = new heartwood_view_controllers_1.ToolBeltStateMachine({
+            vcFactory: views.getFactory(),
+            toolBeltVc,
+            connectToApi: async () => spruce_test_fixtures_1.fake.getClient(),
+            context: Object.assign(Object.assign({}, views.getRouter().buildLoadOptions()), { event,
+                calendarVc, cancelEvent: () => { } }),
+        });
+        const connectToApi = async () => spruce_test_fixtures_1.fake.getClient();
+        const preferences = new FakeRemotePreferences({ connectToApi });
+        const remoteEventsStore = new FakeRemoteEventStore();
+        const events = new SpyEventManager_1.default({
+            calendarVc,
+            sm,
+            dates: calendar_utils_1.dateUtil,
+            remoteVc: {
+                fetchRemoteController: async (name) => factory.getController(name),
+            },
+            askForUpdateStrategy: async () => {
+                return 'all';
+            },
+            events: remoteEventsStore,
+            preferences,
+        });
+        await events.load();
+        events.silentlyAddEvent(event);
+        const people = new SpyPeopleManager_1.default({
+            calendarVc,
+            connectToApi,
+            preferences,
+            getVisibleEvents: () => [],
+        });
+        await sm.updateContext({ events, people });
+        await sm.on('did-update-context', () => {
+            calendarVc.updateEvent(event.id, Object.assign({}, sm.getContext().event));
+        });
+        //@ts-ignore
+        return { stateMachine: sm, toolBeltVc, calendarVc, events };
+    }
+}
+exports.default = CalendarToolBeltStateMachineTestFactory;
+class FakeRemotePreferences extends RemotePreferencesStore_1.default {
+    async loadPreferences() { }
+    async save() { }
+}
+class FakeRemoteEventStore {
+    async load(_options) { }
+    async persist(event) {
+        const e = Object.assign(Object.assign({ dateCreated: new Date().getTime() }, heartwood_view_controllers_1.calendarSeeder.generateEventValues()), event);
+        if (draftGenerator_1.default.isDraftId(e.id)) {
+            e.id = (0, test_utils_1.generateId)();
+        }
+        this.lastPersistedEvent = e;
+        return e;
+    }
+    setCalendarId(_id) { }
+    clearCalendarId() { }
+    getCalendarId() {
+        return undefined;
+    }
+    async waitForPendingSaves() { }
+    async cancelEvent(_id) { }
+    async getSchedules(_options) {
+        return [];
+    }
+    async getEventTypes() {
+        return [];
+    }
+    async getCalendars() {
+        return [];
+    }
+}
+exports.FakeRemoteEventStore = FakeRemoteEventStore;

package/build/esm/__tests__/support/CalendarToolBeltStateMachineTestFactory.d.ts

@@ -0,0 +1,39 @@
+import { SpruceSchemas } from '@sprucelabs/calendar-utils';
+import { ToolBeltViewController } from '@sprucelabs/heartwood-view-controllers';
+import { ViewFixture } from '@sprucelabs/spruce-test-fixtures';
+import { GetScheduleOptions, RemoteEventStore } from '../../stores/RemoteEventStore';
+import { CalendarToolBeltStateMachine, UpdateEvent } from '../../types/calendar.types';
+import CalendarViewController from '../../viewControllers/Calendar.vc';
+import SpyEventManager from './SpyEventManager';
+export default class CalendarToolBeltStateMachineTestFactory {
+    static StateMachine(views: ViewFixture): Promise<{
+        stateMachine: CalendarToolBeltStateMachine;
+        toolBeltVc: ToolBeltViewController;
+        calendarVc: CalendarViewController;
+        events: SpyEventManager;
+    }>;
+}
+declare module '@sprucelabs/heartwood-view-controllers/build/types/heartwood.types' {
+    interface ViewControllerMap {
+        'calendar.calendar': CalendarViewController;
+    }
+    interface ViewControllerOptionsMap {
+        'calendar.calendar': ConstructorParameters<typeof CalendarViewController>[0];
+    }
+}
+export declare class FakeRemoteEventStore implements RemoteEventStore {
+    lastPersistedEvent?: SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent;
+    load(_options: {
+        organizationId: string;
+        locationId: string;
+    }): Promise<void>;
+    persist(event: UpdateEvent): Promise<SpruceSchemas.CalendarUtils.v2021_05_19.CalendarEvent>;
+    setCalendarId(_id: string): void;
+    clearCalendarId(): void;
+    getCalendarId(): string | undefined;
+    waitForPendingSaves(): Promise<void>;
+    cancelEvent(_id: string): Promise<void>;
+    getSchedules(_options: GetScheduleOptions): Promise<SpruceSchemas.HeartwoodViewControllers.v2021_02_11.CalendarEvent[]>;
+    getEventTypes(): Promise<SpruceSchemas.Calendar.v2021_05_19.CalendarEventType[]>;
+    getCalendars(): Promise<SpruceSchemas.Calendar.v2021_05_19.Calendar[]>;
+}

package/build/esm/__tests__/support/CalendarToolBeltStateMachineTestFactory.js

@@ -0,0 +1,126 @@
+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 { calendarSeeder, ToolBeltStateMachine, } from '@sprucelabs/heartwood-view-controllers';
+import { fake } from '@sprucelabs/spruce-test-fixtures';
+import { generateId } from '@sprucelabs/test-utils';
+import RemotePreferencesStore from '../../stores/RemotePreferencesStore.js';
+import draftEventGenerator from '../../utilities/draftGenerator.js';
+import CalendarViewController from '../../viewControllers/Calendar.vc.js';
+import SpyEventManager from './SpyEventManager.js';
+import SpyPeopleManager from './SpyPeopleManager.js';
+export default class CalendarToolBeltStateMachineTestFactory {
+    static StateMachine(views) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const factory = views.getFactory();
+            if (!factory.hasController('calendar.calendar')) {
+                factory.mixinControllers({
+                    //@ts-ignore
+                    'calendar.calendar': CalendarViewController,
+                });
+            }
+            const toolBeltVc = views.Controller('toolBelt', {});
+            const event = calendarSeeder.generateEventValues();
+            const calendarVc = views.Controller('calendar.calendar', {
+                onAddDraftEvent: () => { },
+                onEventSwapped(draft, saved) {
+                    return events.silentlySwapEvent(draft.id, saved);
+                },
+            });
+            calendarVc.addEvent(event);
+            const sm = new ToolBeltStateMachine({
+                vcFactory: views.getFactory(),
+                toolBeltVc,
+                connectToApi: () => __awaiter(this, void 0, void 0, function* () { return fake.getClient(); }),
+                context: Object.assign(Object.assign({}, views.getRouter().buildLoadOptions()), { event,
+                    calendarVc, cancelEvent: () => { } }),
+            });
+            const connectToApi = () => __awaiter(this, void 0, void 0, function* () { return fake.getClient(); });
+            const preferences = new FakeRemotePreferences({ connectToApi });
+            const remoteEventsStore = new FakeRemoteEventStore();
+            const events = new SpyEventManager({
+                calendarVc,
+                sm,
+                dates: dateUtil,
+                remoteVc: {
+                    fetchRemoteController: (name) => __awaiter(this, void 0, void 0, function* () { return factory.getController(name); }),
+                },
+                askForUpdateStrategy: () => __awaiter(this, void 0, void 0, function* () {
+                    return 'all';
+                }),
+                events: remoteEventsStore,
+                preferences,
+            });
+            yield events.load();
+            events.silentlyAddEvent(event);
+            const people = new SpyPeopleManager({
+                calendarVc,
+                connectToApi,
+                preferences,
+                getVisibleEvents: () => [],
+            });
+            yield sm.updateContext({ events, people });
+            yield sm.on('did-update-context', () => {
+                calendarVc.updateEvent(event.id, Object.assign({}, sm.getContext().event));
+            });
+            //@ts-ignore
+            return { stateMachine: sm, toolBeltVc, calendarVc, events };
+        });
+    }
+}
+class FakeRemotePreferences extends RemotePreferencesStore {
+    loadPreferences() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    save() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+}
+export class FakeRemoteEventStore {
+    load(_options) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    persist(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const e = Object.assign(Object.assign({ dateCreated: new Date().getTime() }, calendarSeeder.generateEventValues()), event);
+            if (draftEventGenerator.isDraftId(e.id)) {
+                e.id = generateId();
+            }
+            this.lastPersistedEvent = e;
+            return e;
+        });
+    }
+    setCalendarId(_id) { }
+    clearCalendarId() { }
+    getCalendarId() {
+        return undefined;
+    }
+    waitForPendingSaves() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    cancelEvent(_id) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    getSchedules(_options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    getEventTypes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    getCalendars() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sprucelabs/spruce-calendar-components",
   "description": "Calendar components for working with calendars and Sprucebot.",
-  "version": "22.7.11",
+  "version": "22.7.12",
   "skill": {
     "namespace": "calendar"
   },
@@ -14,6 +14,10 @@
   "module": "./build/esm/index-components.js",
   "sideEffects": false,
   "files": [
+    "build/__tests__/support/CalendarToolBeltStateMachineTestFactory.js",
+    "build/__tests__/support/CalendarToolBeltStateMachineTestFactory.d.ts",
+    "build/esm/__tests__/support/CalendarToolBeltStateMachineTestFactory.js",
+    "build/esm/__tests__/support/CalendarToolBeltStateMachineTestFactory.d.ts",
     "build/__tests__/support/SpyEventManager.js",
     "build/__tests__/support/SpyEventManager.d.ts",
     "build/esm/__tests__/support/SpyEventManager.js",
@@ -166,7 +170,7 @@
     "build/noSchedules/peopleToPeopleWithoutSchedules.d.ts",
     "build/esm/noSchedules/peopleToPeopleWithoutSchedules.js",
     "build/esm/noSchedules/peopleToPeopleWithoutSchedules.d.ts"
-],
+  ],
   "keywords": [],
   "scripts": {
     "release": "npm publish"