All files / src/domains/hands store.ts

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/**
 * Hands Domain Store
 *
 * Valtio-based state management for hands/automation.
 */
import { proxy, subscribe } from 'valtio';
import type { Hand, HandRun, Trigger, ApprovalRequest, HandsState } from './types';
 
// === Store Interface ===
 
export interface HandsStore extends HandsState {
  // Actions
  setHands: (hands: Hand[]) => void;
  updateHand: (id: string, updates: Partial<Hand>) => void;
  addRun: (run: HandRun) => void;
  updateRun: (runId: string, updates: Partial<HandRun>) => void;
  setTriggers: (triggers: Trigger[]) => void;
  updateTrigger: (id: string, updates: Partial<Trigger>) => void;
  addApproval: (request: ApprovalRequest) => void;
  removeApproval: (id: string) => void;
  clearApprovals: () => void;
  setLoading: (loading: boolean) => void;
  setError: (error: string | null) => void;
}
 
// === Create Proxy State ===
 
export const handsStore = proxy<HandsStore>({
  // Initial state
  hands: [],
  runs: {},
  triggers: [],
  approvalQueue: [],
  isLoading: false,
  error: null,
 
  // === Actions ===
 
  setHands: (hands: Hand[]) => {
    handsStore.hands = hands;
  },
 
  updateHand: (id: string, updates: Partial<Hand>) => {
    const hand = handsStore.hands.find(h => h.id === id);
    if (hand) {
      Object.assign(hand, updates);
    }
  },
 
  addRun: (run: HandRun) => {
    handsStore.runs[run.runId] = run;
  },
 
  updateRun: (runId: string, updates: Partial<HandRun>) => {
    if (handsStore.runs[runId]) {
      Object.assign(handsStore.runs[runId], updates);
    }
  },
 
  setTriggers: (triggers: Trigger[]) => {
    handsStore.triggers = triggers;
  },
 
  updateTrigger: (id: string, updates: Partial<Trigger>) => {
    const trigger = handsStore.triggers.find(t => t.id === id);
    if (trigger) {
      Object.assign(trigger, updates);
    }
  },
 
  addApproval: (request: ApprovalRequest) => {
    // Check if already exists
    const exists = handsStore.approvalQueue.some(a => a.id === request.id);
    if (!exists) {
      handsStore.approvalQueue.push(request);
    }
  },
 
  removeApproval: (id: string) => {
    const index = handsStore.approvalQueue.findIndex(a => a.id === id);
    if (index >= 0) {
      handsStore.approvalQueue.splice(index, 1);
    }
  },
 
  clearApprovals: () => {
    handsStore.approvalQueue = [];
  },
 
  setLoading: (loading: boolean) => {
    handsStore.isLoading = loading;
  },
 
  setError: (error: string | null) => {
    handsStore.error = error;
  },
});
 
// === Dev Mode Logging ===
 
if (import.meta.env.DEV) {
  subscribe(handsStore, (ops) => {
    console.log('[HandsStore] Changes:', ops);
  });
}