mvc-kit 2.13.0 → 2.13.2

package/examples/react/WorkerApp/src/resources/MessagesResource.ts

@@ -0,0 +1,32 @@
+import { Resource, Pending, singleton } from 'mvc-kit';
+import type { FeedPage } from 'mvc-kit';
+import type { MessageState } from '../types/message';
+import { fetchMessages, sendMessage } from '../mock/messages';
+import { AppEventBus } from '../events/AppEventBus';
+
+export interface SendMessageMeta {
+  recipientName: string;
+  preview: string;
+}
+
+export class MessagesResource extends Resource<MessageState> {
+  private bus = singleton(AppEventBus);
+
+  readonly pending = new Pending<string, SendMessageMeta>();
+
+  async loadMessages(conversationId: string, signal?: AbortSignal, opts?: { cursor?: string | null }): Promise<FeedPage<MessageState>> {
+    return fetchMessages(conversationId, signal, opts);
+  }
+
+  /** Enqueue a message send via Pending for automatic retry on failure. */
+  enqueueSend(tempId: string, conversationId: string, senderId: string, text: string, recipientName: string) {
+    this.pending.enqueue(tempId, 'send', async (signal) => {
+      const message = await sendMessage(conversationId, senderId, text, signal);
+      this.upsert(message);
+    }, { recipientName, preview: text.slice(0, 50) });
+  }
+
+  protected onDispose() {
+    this.pending.dispose();
+  }
+}

package/examples/react/WorkerApp/src/resources/ShiftResource.ts

@@ -0,0 +1,73 @@
+import { Resource, Pending, singleton, isAbortError } from 'mvc-kit';
+import type { ShiftState } from '../types/shift';
+import * as shiftApi from '../mock/shifts';
+import { AppEventBus } from '../events/AppEventBus';
+
+export interface ShiftOpMeta {
+  action: string;
+  siteName: string;
+}
+
+export class ShiftResource extends Resource<ShiftState> {
+  private bus = singleton(AppEventBus);
+
+  readonly pending = new Pending<string, ShiftOpMeta>();
+
+  async loadCurrent(workerId: string) {
+    const shift = await shiftApi.fetchCurrentShift(workerId, this.disposeSignal);
+    if (shift) {
+      this.reset([shift]);
+    } else {
+      this.reset([]);
+    }
+  }
+
+  clockIn(workerId: string, siteId: string, siteName: string) {
+    const opId = `clockin-${Date.now()}`;
+    this.pending.enqueue(opId, 'clockIn', async (signal) => {
+      const shift = await shiftApi.clockIn(workerId, siteId, signal);
+      this.reset([shift]);
+      this.bus.emit('toast:show', { message: 'Clocked in!', severity: 'success' });
+    }, { action: 'Clock In', siteName });
+  }
+
+  clockOut(shiftId: string, siteName: string) {
+    const opId = `clockout-${Date.now()}`;
+    // Optimistic: clear shift immediately
+    const snapshot = [...this.items];
+    this.reset([]);
+
+    this.pending.enqueue(opId, 'clockOut', async (signal) => {
+      try {
+        await shiftApi.clockOut(shiftId, signal);
+        this.bus.emit('toast:show', { message: 'Clocked out!', severity: 'success' });
+      } catch (e) {
+        if (!isAbortError(e)) {
+          // Rollback optimistic update
+          this.reset(snapshot);
+        }
+        throw e;
+      }
+    }, { action: 'Clock Out', siteName });
+  }
+
+  startBreak(shiftId: string, siteName: string) {
+    const opId = `break-start-${Date.now()}`;
+    this.pending.enqueue(opId, 'startBreak', async (signal) => {
+      const shift = await shiftApi.startBreak(shiftId, signal);
+      this.reset([shift]);
+    }, { action: 'Start Break', siteName });
+  }
+
+  endBreak(shiftId: string, siteName: string) {
+    const opId = `break-end-${Date.now()}`;
+    this.pending.enqueue(opId, 'endBreak', async (signal) => {
+      const shift = await shiftApi.endBreak(shiftId, signal);
+      this.reset([shift]);
+    }, { action: 'End Break', siteName });
+  }
+
+  protected onDispose() {
+    this.pending.dispose();
+  }
+}

package/examples/react/WorkerApp/src/resources/SitesResource.ts

@@ -0,0 +1,11 @@
+import { Resource } from 'mvc-kit';
+import type { SiteState } from '../types/site';
+import { MOCK_SITES } from '../mock/sites';
+import { mockFetch } from '../mock/delay';
+
+export class SitesResource extends Resource<SiteState> {
+  async loadAll() {
+    const data = await mockFetch(MOCK_SITES, undefined, this.disposeSignal);
+    this.reset(data);
+  }
+}

package/examples/react/WorkerApp/src/resources/WorkersResource.ts

@@ -0,0 +1,11 @@
+import { Resource } from 'mvc-kit';
+import type { WorkerState } from '../types/worker';
+import { MOCK_WORKERS } from '../mock/workers';
+import { mockFetch } from '../mock/delay';
+
+export class WorkersResource extends Resource<WorkerState> {
+  async loadAll() {
+    const data = await mockFetch(MOCK_WORKERS, undefined, this.disposeSignal);
+    this.reset(data);
+  }
+}