mvc-kit 2.12.5 → 2.13.1

package/examples/react/WorkerApp/src/components/shift/ShiftPage.tsx

@@ -0,0 +1,98 @@
+import { useLocal } from 'mvc-kit/react';
+import { ShiftViewModel } from '../../viewmodels/ShiftViewModel';
+import { ShiftTimer } from './ShiftTimer';
+import { SiteSelector } from './SiteSelector';
+import { PendingBanner } from '../shared/PendingBanner';
+import { Spinner } from '../shared/Spinner';
+
+export function ShiftPage() {
+  const [state, vm] = useLocal(ShiftViewModel, { selectedSiteId: null, now: Date.now() });
+  const { loading } = vm.async.load;
+
+  return (
+    <div>
+      <h1 className="page-title">My Shift</h1>
+
+      <PendingBanner
+        pending={vm.pending}
+        label="shift operations"
+        renderEntry={entry => (
+          <span>{entry.meta?.action} at {entry.meta?.siteName} — {entry.error}</span>
+        )}
+      />
+
+      {loading && <Spinner />}
+
+      {!loading && !vm.isOnShift && (
+        <div className="card">
+          <h2 style={{ marginBottom: '1rem' }}>Clock In</h2>
+          <p style={{ color: 'var(--color-text-secondary)', marginBottom: '1rem' }}>
+            Select a work site and clock in to start your shift.
+          </p>
+          <SiteSelector
+            sites={vm.availableSites}
+            selectedId={state.selectedSiteId}
+            onSelect={id => vm.selectSite(id)}
+          />
+          <button
+            className="btn btn-primary"
+            disabled={!state.selectedSiteId || vm.hasPendingOps}
+            onClick={() => vm.clockIn()}
+          >
+            {vm.hasPendingOps ? 'Processing...' : 'Clock In'}
+          </button>
+        </div>
+      )}
+
+      {!loading && vm.isOnShift && (
+        <div className="card">
+          <ShiftTimer
+            shiftTime={vm.formattedShiftTime}
+            breakTime={vm.formattedBreakTime}
+            siteName={vm.currentSiteName}
+            isOnBreak={vm.isOnBreak}
+          />
+
+          <div className="shift-actions">
+            {vm.isOnBreak ? (
+              <button
+                className="btn btn-primary"
+                onClick={() => vm.endBreak()}
+                disabled={vm.hasPendingOps}
+              >
+                End Break
+              </button>
+            ) : (
+              <button
+                className="btn btn-secondary"
+                onClick={() => vm.startBreak()}
+                disabled={vm.hasPendingOps}
+              >
+                Start Break
+              </button>
+            )}
+
+            <button
+              className="btn btn-danger"
+              onClick={() => vm.clockOut()}
+              disabled={vm.hasPendingOps}
+            >
+              Clock Out
+            </button>
+          </div>
+
+          {vm.hasFailedOps && (
+            <div style={{ marginTop: '1rem' }}>
+              <button className="btn btn-sm btn-primary" onClick={() => vm.retryAll()}>
+                Retry Failed
+              </button>
+              <button className="btn btn-sm btn-secondary" style={{ marginLeft: '0.5rem' }} onClick={() => vm.dismissAll()}>
+                Dismiss
+              </button>
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}

package/examples/react/WorkerApp/src/components/shift/ShiftTimer.tsx

@@ -0,0 +1,24 @@
+interface ShiftTimerProps {
+  shiftTime: string;
+  breakTime: string;
+  siteName: string;
+  isOnBreak: boolean;
+}
+
+export function ShiftTimer({ shiftTime, breakTime, siteName, isOnBreak }: ShiftTimerProps) {
+  return (
+    <div className="shift-timer">
+      <div className="shift-timer-site">{siteName}</div>
+      <div className="shift-timer-clock">
+        <div className="timer-value">{shiftTime}</div>
+        <div className="timer-label">Shift Duration</div>
+      </div>
+      <div className="shift-timer-break">
+        <span className={`badge ${isOnBreak ? 'badge-maintenance' : 'badge-inactive'}`}>
+          {isOnBreak ? 'On Break' : 'Working'}
+        </span>
+        <span className="timer-break-value">Break: {breakTime}</span>
+      </div>
+    </div>
+  );
+}

package/examples/react/WorkerApp/src/components/shift/SiteSelector.tsx

@@ -0,0 +1,27 @@
+import type { SiteState } from '../../types/site';
+
+interface SiteSelectorProps {
+  sites: SiteState[];
+  selectedId: string | null;
+  onSelect: (id: string) => void;
+}
+
+export function SiteSelector({ sites, selectedId, onSelect }: SiteSelectorProps) {
+  return (
+    <div className="form-group">
+      <label className="form-label">Work Site</label>
+      <select
+        className="form-select"
+        value={selectedId ?? ''}
+        onChange={e => onSelect(e.target.value)}
+      >
+        <option value="">Select a site...</option>
+        {sites.map(site => (
+          <option key={site.id} value={site.id}>
+            {site.name} — {site.address}
+          </option>
+        ))}
+      </select>
+    </div>
+  );
+}

package/examples/react/WorkerApp/src/components/sites/SiteFilters.tsx

@@ -0,0 +1,61 @@
+import type { SiteState } from '../../types/site';
+
+interface SiteFiltersProps {
+  search: string;
+  typeFilter: 'all' | SiteState['type'];
+  statusFilter: 'all' | SiteState['status'];
+  onSearchChange: (v: string) => void;
+  onTypeFilterChange: (v: 'all' | SiteState['type']) => void;
+  onStatusFilterChange: (v: 'all' | SiteState['status']) => void;
+}
+
+export function SiteFilters({
+  search,
+  typeFilter,
+  statusFilter,
+  onSearchChange,
+  onTypeFilterChange,
+  onStatusFilterChange,
+}: SiteFiltersProps) {
+  return (
+    <div className="filters">
+      <div className="filter-group">
+        <label className="filter-label">Search</label>
+        <input
+          className="filter-input"
+          type="text"
+          value={search}
+          onChange={e => onSearchChange(e.target.value)}
+          placeholder="Search sites..."
+        />
+      </div>
+      <div className="filter-group">
+        <label className="filter-label">Type</label>
+        <select
+          className="filter-select"
+          value={typeFilter}
+          onChange={e => onTypeFilterChange(e.target.value as any)}
+        >
+          <option value="all">All Types</option>
+          <option value="residential">Residential</option>
+          <option value="commercial">Commercial</option>
+          <option value="industrial">Industrial</option>
+          <option value="infrastructure">Infrastructure</option>
+        </select>
+      </div>
+      <div className="filter-group">
+        <label className="filter-label">Status</label>
+        <select
+          className="filter-select"
+          value={statusFilter}
+          onChange={e => onStatusFilterChange(e.target.value as any)}
+        >
+          <option value="all">All Statuses</option>
+          <option value="active">Active</option>
+          <option value="paused">Paused</option>
+          <option value="completed">Completed</option>
+        </select>
+      </div>
+    </div>
+  );
+}

package/examples/react/WorkerApp/src/components/sites/SitesPage.tsx

@@ -0,0 +1,102 @@
+import { useLocal, DataTable } from 'mvc-kit/react';
+import type { Column } from 'mvc-kit/react';
+import { SitesViewModel } from '../../viewmodels/SitesViewModel';
+import { SiteFilters } from './SiteFilters';
+import { Spinner } from '../shared/Spinner';
+import { ErrorBanner } from '../shared/ErrorBanner';
+import type { SiteState } from '../../types/site';
+
+const columns: Column<SiteState>[] = [
+  {
+    key: 'name',
+    header: 'Name',
+    render: site => <span style={{ fontWeight: 500 }}>{site.name}</span>,
+    sortable: true,
+  },
+  {
+    key: 'type',
+    header: 'Type',
+    render: site => (
+      <span className={`badge badge-${site.type === 'residential' ? 'admin' : site.type === 'commercial' ? 'manager' : 'member'}`}>
+        {site.type}
+      </span>
+    ),
+  },
+  {
+    key: 'address',
+    header: 'Address',
+    render: site => site.address,
+    sortable: true,
+  },
+  {
+    key: 'status',
+    header: 'Status',
+    render: site => <span className={`badge badge-${site.status}`}>{site.status}</span>,
+    sortable: true,
+  },
+  {
+    key: 'workerCount',
+    header: 'Workers',
+    render: site => site.workerCount,
+    sortable: true,
+  },
+];
+
+export function SitesPage() {
+  const [state, vm] = useLocal(SitesViewModel, {
+    search: '',
+    typeFilter: 'all',
+    statusFilter: 'all',
+  });
+  const { loading, error } = vm.async.load;
+// console.log('vm.paged', vm.paged)
+  return (
+    <div>
+      <h1 className="page-title">Work Sites</h1>
+
+      <SiteFilters
+        search={state.search}
+        typeFilter={state.typeFilter}
+        statusFilter={state.statusFilter}
+        onSearchChange={v => vm.setSearch(v)}
+        onTypeFilterChange={vm.setTypeFilter}
+        onStatusFilterChange={v => vm.setStatusFilter(v)}
+      />
+
+      <div className="results-bar">
+        <span>Showing {vm.filteredCount} of {vm.total}</span>
+      </div>
+
+      {vm.selection.hasSelection && (
+        <div className="selection-bar">
+          <span>{vm.selection.count} selected</span>
+        </div>
+      )}
+
+      <DataTable
+        items={vm.paged}
+        columns={columns}
+        loading={loading}
+        error={error}
+        sort={vm.sorting}
+        selection={vm.selection}
+        pagination={vm.pagination}
+        paginationTotal={vm.filteredCount}
+        renderLoading={() => <Spinner />}
+        renderError={msg => <ErrorBanner message={msg} />}
+        renderEmpty={() => <div className="empty-state">No sites match your filters.</div>}
+        renderSortIndicator={({ active, direction }) => (
+          <span>{active ? (direction === 'asc' ? ' ↑' : ' ↓') : ''}</span>
+        )}
+        renderPagination={info => (
+          <div className="pagination-bar">
+            <button disabled={!info.hasPrev} onClick={info.goPrev}>Prev</button>
+            <span>Page {info.page} of {info.pageCount}</span>
+            <button disabled={!info.hasNext} onClick={info.goNext}>Next</button>
+          </div>
+        )}
+        className="table-container"
+      />
+    </div>
+  );
+}

package/examples/react/WorkerApp/src/env.d.ts

@@ -0,0 +1,10 @@
+declare const __MVC_KIT_DEV__: boolean;
+
+declare module 'react-dom/client' {
+  import type { ReactNode } from 'react';
+  interface Root {
+    render(children: ReactNode): void;
+    unmount(): void;
+  }
+  export function createRoot(container: Element): Root;
+}

package/examples/react/WorkerApp/src/events/AppEventBus.ts

@@ -0,0 +1,7 @@
+import { EventBus } from 'mvc-kit';
+
+export interface AppEvents {
+  'toast:show': { message: string; severity: 'success' | 'error' | 'info' };
+}
+
+export class AppEventBus extends EventBus<AppEvents> {}

package/examples/react/WorkerApp/src/main.tsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { App } from './App';
+import './styles.css';
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+);

package/examples/react/WorkerApp/src/mock/MockWebSocket.ts

@@ -0,0 +1,38 @@
+export interface MockWSConfig {
+  minInterval: number;
+  maxInterval: number;
+  generator: () => any;
+}
+
+export class MockWebSocket {
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private closed = false;
+
+  constructor(private config: MockWSConfig) {}
+
+  connect(onMessage: (data: any) => void, signal?: AbortSignal): void {
+    if (signal?.aborted) return;
+    signal?.addEventListener('abort', () => this.close(), { once: true });
+    this.scheduleNext(onMessage);
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+
+  private scheduleNext(onMessage: (data: any) => void): void {
+    if (this.closed) return;
+    const { minInterval, maxInterval, generator } = this.config;
+    const interval = minInterval + Math.random() * (maxInterval - minInterval);
+    this.timer = setTimeout(() => {
+      if (this.closed) return;
+      onMessage(generator());
+      this.scheduleNext(onMessage);
+    }, interval);
+  }
+}

package/examples/react/WorkerApp/src/mock/delay.ts

@@ -0,0 +1,31 @@
+export function delay(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException('Aborted', 'AbortError'));
+      return;
+    }
+
+    const timer = setTimeout(resolve, ms);
+
+    signal?.addEventListener('abort', () => {
+      clearTimeout(timer);
+      reject(new DOMException('Aborted', 'AbortError'));
+    }, { once: true });
+  });
+}
+
+export async function mockFetch<T>(data: T, ms?: number, signal?: AbortSignal): Promise<T> {
+  const jitter = 200 + Math.random() * 300;
+  await delay(ms ?? jitter, signal);
+  return data;
+}
+
+/** ~30% failure rate to simulate unreliable network */
+export async function mockFetchUnreliable<T>(data: T, ms?: number, signal?: AbortSignal): Promise<T> {
+  const jitter = 200 + Math.random() * 400;
+  await delay(ms ?? jitter, signal);
+  if (Math.random() < 0.3) {
+    throw new Error('Network error: request failed');
+  }
+  return data;
+}

package/examples/react/WorkerApp/src/mock/messages.ts

@@ -0,0 +1,120 @@
+import type { MessageState } from '../types/message';
+import type { ConversationState } from '../types/conversation';
+import type { FeedPage } from 'mvc-kit';
+import { mockFetch, mockFetchUnreliable } from './delay';
+
+const PAGE_SIZE = 15;
+
+// --- Seed conversations ---
+const MOCK_CONVERSATIONS: ConversationState[] = [
+  { id: 'conv1', participantIds: ['w1', 'w2'], lastMessage: 'On my way to the site', unreadCount: 2, updatedAt: Date.now() - 60000 },
+  { id: 'conv2', participantIds: ['w1', 'w3', 'w4'], lastMessage: 'Need more supplies at Riverside', unreadCount: 0, updatedAt: Date.now() - 120000 },
+  { id: 'conv3', participantIds: ['w1', 'w5'], lastMessage: 'Break time?', unreadCount: 1, updatedAt: Date.now() - 300000 },
+  { id: 'conv4', participantIds: ['w1', 'w6'], lastMessage: 'Wiring specs updated', unreadCount: 0, updatedAt: Date.now() - 600000 },
+];
+
+// --- Seed messages ---
+const allMessages = new Map<string, MessageState[]>();
+
+function seedMessages(convId: string, participants: string[]): MessageState[] {
+  const texts = [
+    'Hey, are you at the site yet?',
+    'Just got here. Parking is a mess.',
+    'I\'ll be there in 10 minutes.',
+    'Can you check the electrical panel on floor 3?',
+    'Done. Everything looks good.',
+    'Great work today!',
+    'Need more 2x4s for the framing.',
+    'I\'ll call the supplier.',
+    'Safety inspection is at 2pm.',
+    'Got it, I\'ll make sure the crew knows.',
+    'Weather looks bad tomorrow.',
+    'We should cover the exposed sections.',
+    'Lunch run — want anything?',
+    'Just a coffee, thanks.',
+    'The foreman wants a progress report by EOD.',
+    'On it. Almost done with section B.',
+    'New blueprints came in.',
+    'I\'ll review them tonight.',
+    'Nice, the pour came out clean.',
+    'Couldn\'t have done it without the crew.',
+  ];
+
+  const messages: MessageState[] = [];
+  const count = 20 + Math.floor(Math.random() * 10);
+  const baseTime = Date.now() - count * 60000;
+
+  for (let i = 0; i < count; i++) {
+    messages.push({
+      id: `${convId}-msg${i}`,
+      conversationId: convId,
+      senderId: participants[i % participants.length]!,
+      text: texts[i % texts.length]!,
+      sentAt: baseTime + i * 60000,
+    });
+  }
+  return messages;
+}
+
+for (const conv of MOCK_CONVERSATIONS) {
+  allMessages.set(conv.id, seedMessages(conv.id, conv.participantIds));
+}
+
+// --- API ---
+
+export async function fetchConversations(workerId: string, signal?: AbortSignal): Promise<ConversationState[]> {
+  const convs = MOCK_CONVERSATIONS.filter(c => c.participantIds.includes(workerId));
+  return mockFetch(convs, undefined, signal);
+}
+
+export async function fetchMessages(
+  conversationId: string,
+  signal?: AbortSignal,
+  opts?: { cursor?: string | null },
+): Promise<FeedPage<MessageState>> {
+  const messages = allMessages.get(conversationId) ?? [];
+  // Sort newest first for cursor-based pagination
+  const sorted = [...messages].sort((a, b) => b.sentAt - a.sentAt);
+
+  let startIndex = 0;
+  if (opts?.cursor) {
+    const cursorIdx = sorted.findIndex(m => m.id === opts.cursor);
+    if (cursorIdx >= 0) startIndex = cursorIdx + 1;
+  }
+
+  const page = sorted.slice(startIndex, startIndex + PAGE_SIZE);
+  const hasMore = startIndex + PAGE_SIZE < sorted.length;
+  const cursor = page.length > 0 ? page[page.length - 1]!.id : null;
+
+  return mockFetch({ items: page.reverse(), hasMore, cursor }, undefined, signal);
+}
+
+export async function sendMessage(
+  conversationId: string,
+  senderId: string,
+  text: string,
+  signal?: AbortSignal,
+): Promise<MessageState> {
+  const message: MessageState = {
+    id: `${conversationId}-msg${Date.now()}`,
+    conversationId,
+    senderId,
+    text,
+    sentAt: Date.now(),
+  };
+
+  // Store in mock database
+  const existing = allMessages.get(conversationId) ?? [];
+  existing.push(message);
+  allMessages.set(conversationId, existing);
+
+  // Update conversation
+  const conv = MOCK_CONVERSATIONS.find(c => c.id === conversationId);
+  if (conv) {
+    conv.lastMessage = text;
+    conv.updatedAt = Date.now();
+  }
+
+  // Unreliable — ~30% chance of failure to showcase Pending retries
+  return mockFetchUnreliable(message, undefined, signal);
+}

package/examples/react/WorkerApp/src/mock/shifts.ts

@@ -0,0 +1,57 @@
+import type { ShiftState } from '../types/shift';
+import { mockFetchUnreliable } from './delay';
+
+let shiftStore: ShiftState | null = null;
+
+export async function fetchCurrentShift(workerId: string, signal?: AbortSignal): Promise<ShiftState | null> {
+  return mockFetchUnreliable(shiftStore, undefined, signal);
+}
+
+export async function clockIn(workerId: string, siteId: string, signal?: AbortSignal): Promise<ShiftState> {
+  const shift: ShiftState = {
+    id: `shift-${Date.now()}`,
+    workerId,
+    siteId,
+    clockIn: Date.now(),
+    clockOut: null,
+    breaks: [],
+  };
+  shiftStore = shift;
+  return mockFetchUnreliable(shift, undefined, signal);
+}
+
+export async function clockOut(shiftId: string, signal?: AbortSignal): Promise<ShiftState> {
+  if (!shiftStore || shiftStore.id !== shiftId) {
+    throw new Error('No active shift');
+  }
+  // End any open break
+  const breaks = shiftStore.breaks.map(b =>
+    b.end === null ? { ...b, end: Date.now() } : b,
+  );
+  shiftStore = { ...shiftStore, clockOut: Date.now(), breaks };
+  const result = shiftStore;
+  shiftStore = null;
+  return mockFetchUnreliable(result, undefined, signal);
+}
+
+export async function startBreak(shiftId: string, signal?: AbortSignal): Promise<ShiftState> {
+  if (!shiftStore || shiftStore.id !== shiftId) {
+    throw new Error('No active shift');
+  }
+  shiftStore = {
+    ...shiftStore,
+    breaks: [...shiftStore.breaks, { start: Date.now(), end: null }],
+  };
+  return mockFetchUnreliable(shiftStore, undefined, signal);
+}
+
+export async function endBreak(shiftId: string, signal?: AbortSignal): Promise<ShiftState> {
+  if (!shiftStore || shiftStore.id !== shiftId) {
+    throw new Error('No active shift');
+  }
+  const breaks = shiftStore.breaks.map(b =>
+    b.end === null ? { ...b, end: Date.now() } : b,
+  );
+  shiftStore = { ...shiftStore, breaks };
+  return mockFetchUnreliable(shiftStore, undefined, signal);
+}

package/examples/react/WorkerApp/src/mock/sites.ts

@@ -0,0 +1,14 @@
+import type { SiteState } from '../types/site';
+
+export const MOCK_SITES: SiteState[] = [
+  { id: 's1', name: 'Riverside Apartments', type: 'residential', status: 'active', address: '120 River St', workerCount: 8 },
+  { id: 's2', name: 'Downtown Office Tower', type: 'commercial', status: 'active', address: '500 Main Ave', workerCount: 15 },
+  { id: 's3', name: 'Harbor Industrial Park', type: 'industrial', status: 'active', address: '80 Harbor Rd', workerCount: 12 },
+  { id: 's4', name: 'Maple Ridge Homes', type: 'residential', status: 'active', address: '45 Maple Ln', workerCount: 6 },
+  { id: 's5', name: 'City Bridge Repair', type: 'infrastructure', status: 'paused', address: 'Bridge St', workerCount: 0 },
+  { id: 's6', name: 'Tech Campus Phase 2', type: 'commercial', status: 'active', address: '200 Innovation Dr', workerCount: 20 },
+  { id: 's7', name: 'Waterfront Condos', type: 'residential', status: 'completed', address: '10 Bay Walk', workerCount: 0 },
+  { id: 's8', name: 'Factory Retrofit', type: 'industrial', status: 'active', address: '300 Industrial Blvd', workerCount: 9 },
+  { id: 's9', name: 'Highway Extension', type: 'infrastructure', status: 'active', address: 'Route 9 North', workerCount: 25 },
+  { id: 's10', name: 'Community Center', type: 'commercial', status: 'paused', address: '15 Park Ave', workerCount: 0 },
+];

package/examples/react/WorkerApp/src/mock/workers.ts

@@ -0,0 +1,12 @@
+import type { WorkerState } from '../types/worker';
+
+export const MOCK_WORKERS: WorkerState[] = [
+  { id: 'w1', name: 'Marcus Johnson', email: 'marcus@example.com', role: 'foreman', status: 'available', avatar: 'MJ' },
+  { id: 'w2', name: 'Sarah Chen', email: 'sarah@example.com', role: 'electrician', status: 'available', avatar: 'SC' },
+  { id: 'w3', name: 'David Kowalski', email: 'david@example.com', role: 'plumber', status: 'on-shift', avatar: 'DK' },
+  { id: 'w4', name: 'Ana Rodriguez', email: 'ana@example.com', role: 'carpenter', status: 'on-shift', avatar: 'AR' },
+  { id: 'w5', name: 'James O\'Brien', email: 'james@example.com', role: 'laborer', status: 'on-break', avatar: 'JO' },
+  { id: 'w6', name: 'Priya Patel', email: 'priya@example.com', role: 'electrician', status: 'offline', avatar: 'PP' },
+];
+
+export const CURRENT_WORKER = MOCK_WORKERS[0]!;

package/examples/react/WorkerApp/src/models/ComposeMessageModel.ts

@@ -0,0 +1,17 @@
+import { Model } from 'mvc-kit';
+import type { ValidationErrors } from 'mvc-kit';
+
+export interface ComposeMessageState {
+  text: string;
+}
+
+export class ComposeMessageModel extends Model<ComposeMessageState> {
+  setText(text: string) { this.set({ text }); }
+
+  protected validate(state: ComposeMessageState): ValidationErrors<ComposeMessageState> {
+    const errors: Partial<Record<keyof ComposeMessageState, string>> = {};
+    if (!state.text.trim()) errors.text = 'Message cannot be empty';
+    if (state.text.length > 500) errors.text = 'Message must be under 500 characters';
+    return errors;
+  }
+}

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

@@ -0,0 +1,10 @@
+import { Resource } from 'mvc-kit';
+import type { ConversationState } from '../types/conversation';
+import { fetchConversations } from '../mock/messages';
+
+export class ConversationsResource extends Resource<ConversationState> {
+  async loadAll(workerId: string) {
+    const data = await fetchConversations(workerId, this.disposeSignal);
+    this.reset(data);
+  }
+}