diff --git a/prd.json b/prd.json index 378ea27..a49d175 100644 --- a/prd.json +++ b/prd.json @@ -324,7 +324,7 @@ "Verify in browser using dev-browser skill" ], "priority": 18, - "passes": false, + "passes": true, "notes": "Dependencies: US-045, US-046" }, { @@ -341,7 +341,7 @@ "Verify in browser using dev-browser skill" ], "priority": 19, - "passes": false, + "passes": true, "notes": "Dependencies: US-045, US-046" }, { @@ -359,7 +359,7 @@ "Verify in browser using dev-browser skill" ], "priority": 20, - "passes": false, + "passes": true, "notes": "Dependencies: US-045, US-048" }, { @@ -376,7 +376,7 @@ "Typecheck passes" ], "priority": 21, - "passes": false, + "passes": true, "notes": "Dependencies: US-043, US-048" }, { @@ -394,7 +394,7 @@ "Verify in browser using dev-browser skill" ], "priority": 22, - "passes": false, + "passes": true, "notes": "Dependencies: US-051" }, { @@ -414,7 +414,7 @@ "Verify in browser using dev-browser skill" ], "priority": 23, - "passes": false, + "passes": true, "notes": "Dependencies: US-052, US-048" } ] diff --git a/progress.txt b/progress.txt index 023908d..2b4b295 100644 --- a/progress.txt +++ b/progress.txt @@ -60,6 +60,16 @@ - `CRDTManager` at `src/lib/collaboration/crdt.ts` wraps a Yjs Y.Doc with Y.Map for nodes and edges. Connects to Supabase Realtime channel for broadcasting updates. - CRDT sync pattern: local React Flow changes → `updateNodes`/`updateEdges` on CRDTManager → Yjs broadcasts to channel; remote broadcasts → Yjs applies update → callbacks set React Flow state. Use `isRemoteUpdateRef` to prevent echo loops. - For Supabase Realtime broadcast of binary data (Yjs updates), convert `Uint8Array` → `Array.from()` for JSON payload, and `new Uint8Array()` on receive. +- For ephemeral real-time data (cursors, typing indicators), use Supabase Realtime broadcast (`channel.send({ type: 'broadcast', event, payload })`) + `.on('broadcast', { event }, callback)` — not persistence-backed +- `RemoteCursors` at `src/components/editor/RemoteCursors.tsx` renders collaborator cursors on canvas. Uses `useViewport()` to transform flow→screen coordinates. Throttle broadcasts to 50ms via timestamp ref. +- Supabase Realtime presence events: `sync` (full state), `join` (arrivals with `newPresences` array), `leave` (departures with `leftPresences` array). Filter `this.userId` to skip own events. +- `CollaborationToast` at `src/components/editor/CollaborationToast.tsx` shows join/leave notifications (bottom-left, auto-dismiss 3s). Uses `getUserColor(userId)` for accent color dot. +- Node lock indicators use `EditorContext` (`nodeLocks` Map, `onNodeFocus`, `onNodeBlur`). Each node component checks `nodeLocks.get(id)` for lock state and renders `NodeLockIndicator` + overlay if locked by another user. +- For ephemeral lock state (node editing locks), broadcast via `node-lock` event with `{ nodeId, userId, displayName, lockedAt }`. Send `nodeId: null` to release. +- `AuditTrailRecorder` at `src/lib/collaboration/auditTrail.ts` records node/edge changes to `audit_trail` table. Uses state diffing (previous vs current Maps), 1-second per-entity debounce, and fire-and-forget Supabase inserts. Only records local changes (guarded by `isRemoteUpdateRef` in FlowchartEditor). +- `ActivityHistorySidebar` at `src/components/editor/ActivityHistorySidebar.tsx` displays audit trail entries in a right sidebar. Rendered inside the canvas `relative flex-1` container. Toggle via `showHistory` state in FlowchartEditor. Exports `AuditEntry` type for consumers. +- To prevent double audit recording when programmatically changing nodes/edges (e.g., revert), set a ref guard (`isRevertingRef`) before `setNodes`/`setEdges` and clear it with `setTimeout(() => ..., 0)`. Check the guard in the CRDT sync effects before calling `auditRef.current.recordNodeChanges()`. +- For async data fetching in components with React Compiler, use a pure fetch function returning `{ data, error, hasMore }` result object, then handle setState in the `.then()` callback with an abort/mount guard — never call setState-containing functions directly inside useEffect. --- @@ -396,3 +406,102 @@ - After successful password update, sign out the user and redirect to login with success message (same as reset-password page) - The modal coexists with the existing /reset-password page - both handle recovery tokens but in different UX patterns --- + +## 2026-01-23 - US-047 +- What was implemented: Live cursor positions on canvas showing collaborators' mouse positions in real-time +- Files changed: + - `src/lib/collaboration/realtime.ts` - Added `CursorPosition`, `RemoteCursor` types, `onCursorUpdate` callback to `RealtimeCallbacks`, broadcast listener for 'cursor' events, and `broadcastCursor()` method + - `src/components/editor/RemoteCursors.tsx` - New component: renders colored arrow cursors with user name labels, smooth position interpolation via CSS transition, 5-second fade-out for inactive cursors, flow-to-screen coordinate transformation using React Flow viewport + - `src/app/editor/[projectId]/FlowchartEditor.tsx` - Added `remoteCursors` state, `cursorThrottleRef` for 50ms throttling, `handleMouseMove` that converts screen→flow coordinates and broadcasts via RealtimeConnection, cleanup of cursors for disconnected users, rendering of RemoteCursors overlay + - `src/app/editor/[projectId]/page.tsx` - Fixed broken JSX structure (malformed HTML nesting and dead code after return) +- **Learnings for future iterations:** + - `screenToFlowPosition` from `useReactFlow()` converts screen-relative mouse coordinates to flow coordinates; for the reverse (rendering cursors), multiply by viewport.zoom and add viewport offset + - Cursor broadcast uses Supabase Realtime broadcast (not presence) for efficiency: `channel.send({ type: 'broadcast', event: 'cursor', payload })`. Broadcast is fire-and-forget (no persistence). + - React Compiler lint treats `Date.now()` as an impure function call — use `useState(() => Date.now())` lazy initializer pattern instead of `useState(Date.now())` + - Throttling mouse events uses a ref storing the last broadcast timestamp (`cursorThrottleRef`), checked at the start of the handler before computing flow position + - Remote cursors are removed when their user disconnects (filtered by `presenceUsers` list changes) + - CSS `transition: transform 80ms linear` provides smooth interpolation between position updates without needing requestAnimationFrame + - The `page.tsx` had a corrupted structure with unclosed tags and dead code — likely from a failed merge. Fixed by restructuring the error/not-found case into a proper early return + - No browser testing tools are available; manual verification is needed. +--- + +## 2026-01-23 - US-050 +- What was implemented: Join/leave toast notifications when collaborators connect or disconnect from the editing session +- Files changed: + - `src/lib/collaboration/realtime.ts` - Added `onPresenceJoin` and `onPresenceLeave` callbacks to `RealtimeCallbacks` type; added Supabase Realtime `presence.join` and `presence.leave` event listeners that filter out own user and invoke callbacks + - `src/components/editor/CollaborationToast.tsx` - New component: renders a compact toast notification with user's presence color dot, "[Name] joined" or "[Name] left" message, auto-dismisses after 3 seconds + - `src/app/editor/[projectId]/FlowchartEditor.tsx` - Added `getUserColor` helper (same hash logic as PresenceAvatars), `collaborationNotifications` state, `onPresenceJoin`/`onPresenceLeave` handlers on RealtimeConnection, `handleDismissNotification` callback, and rendering of CollaborationToast list in bottom-left corner +- **Learnings for future iterations:** + - Supabase Realtime presence has three event types: `sync` (full state), `join` (new arrivals), and `leave` (departures). Each provides an array of presences (`newPresences`/`leftPresences`). Use all three for different purposes. + - The `join` event fires for each newly tracked presence. It includes the presence payload (userId, displayName) that was passed to `channel.track()`. + - Collaboration notifications are positioned `bottom-left` (`left-4`) to avoid overlapping with the existing Toast component which is `bottom-right` (`right-4`). + - The `getUserColor` function is duplicated from PresenceAvatars to avoid circular imports. Both use the same hash-to-color-index algorithm with the same RANDOM_COLORS palette for consistency. + - No browser testing tools are available; manual verification is needed. +--- + +## 2026-01-24 - US-049 +- What was implemented: Node editing lock indicators that show when another collaborator is editing a node +- Files changed: + - `src/lib/collaboration/realtime.ts` - Added `NodeLock` type, `onNodeLockUpdate` callback to `RealtimeCallbacks`, `node-lock` broadcast listener, and `broadcastNodeLock()` method + - `src/components/editor/NodeLockIndicator.tsx` - New component: renders a colored border and name label overlay on locked nodes + - `src/components/editor/EditorContext.tsx` - Extended context with `NodeLockInfo` type, `nodeLocks` (Map), `onNodeFocus`, and `onNodeBlur` callbacks + - `src/components/editor/nodes/DialogueNode.tsx` - Added lock detection, `NodeLockIndicator` rendering, "Being edited by [name]" overlay, `onFocus`/`onBlur` handlers + - `src/components/editor/nodes/VariableNode.tsx` - Same lock indicator pattern as DialogueNode + - `src/components/editor/nodes/ChoiceNode.tsx` - Same lock indicator pattern as DialogueNode + - `src/app/editor/[projectId]/FlowchartEditor.tsx` - Added `nodeLocks` state (Map), `localLockRef` for tracking own lock, `handleNodeFocus`/`handleNodeBlur` callbacks, `onNodeLockUpdate` handler in RealtimeConnection, lock expiry timer (60s check every 5s), lock cleanup on user leave and component unmount, extended `editorContextValue` with lock state +- **Learnings for future iterations:** + - Node lock uses Supabase Realtime broadcast (like cursors) — ephemeral, not persisted to DB. Event name: `node-lock`. + - Lock broadcasting uses `nodeId: string | null` pattern: non-null to acquire lock, `null` to release. The receiving side maps userId to their current lock. + - Lock expiry uses a 60-second timeout checked every 5 seconds via `setInterval`. The `lockedAt` timestamp is broadcast with the lock payload. + - Each node component accesses lock state via `EditorContext` (`nodeLocks` Map). The `NodeLockInfo` type extends `NodeLock` with a `color` field derived from `getUserColor()`. + - `onFocus`/`onBlur` on the node container div fires when any child input gains/loses focus (focus event bubbles), which naturally maps to "user is editing this node". + - Lock release on disconnect: broadcast `null` lock before calling `connection.disconnect()` in the cleanup return of the mount effect. + - Locks from disconnected users are cleaned up in the same effect that removes cursors (filtered by `presenceUsers` list). + - No browser testing tools are available; manual verification is needed. +--- + +## 2026-01-24 - US-051 +- What was implemented: Audit trail recording that writes all node/edge add/update/delete operations to the `audit_trail` table with debouncing and fire-and-forget semantics +- Files changed: + - `src/lib/collaboration/auditTrail.ts` - New `AuditTrailRecorder` class: tracks previous node/edge state, diffs against current state to detect add/update/delete operations, debounces writes per entity (1 second), merges rapid sequential actions (e.g., add+update=add, add+delete=no-op), fire-and-forget Supabase inserts with error logging, flush on destroy + - `src/app/editor/[projectId]/FlowchartEditor.tsx` - Added `auditRef` (AuditTrailRecorder), initialized in mount effect alongside CRDT manager, records node/edge changes in the CRDT sync effects (only for local changes, skipped for remote updates), destroyed on unmount +- **Learnings for future iterations:** + - The audit recorder piggybacks on the same CRDT sync effects that already compute `nodesForCRDT`/`edgesForCRDT` — this avoids duplicating the React Flow → FlowchartNode/Edge conversion. + - The `isRemoteUpdateRef` guard in the sync effects ensures audit entries are only created for local user actions, not for changes received from other collaborators (those users' own recorders will handle their audit entries). + - Debouncing per entity (1 second) prevents rapid edits (e.g., typing in a text field) from flooding the audit table. The merge logic handles transient states (add+delete within 1s = skip). + - The `destroy()` method flushes pending entries synchronously on unmount, ensuring in-flight edits aren't lost when navigating away. + - Supabase `.insert().then()` pattern provides fire-and-forget writes with error logging — the async operation doesn't block the editing flow. + - No browser testing needed — this is a developer/infrastructure story with no UI changes. +--- + +## 2026-01-24 - US-052 +- What was implemented: Activity history sidebar that displays audit trail entries, grouped by time period, with entity selection on click +- Files changed: + - `src/components/editor/ActivityHistorySidebar.tsx` - New component: right sidebar panel showing chronological audit trail entries, grouped by Today/Yesterday/Earlier, with user color accents, entity descriptions, paginated loading (20 per page), and click-to-select entity on canvas + - `src/components/editor/Toolbar.tsx` - Added `onHistory` prop and "History" button in the right toolbar section + - `src/app/editor/[projectId]/FlowchartEditor.tsx` - Added `showHistory` state, `handleHistorySelectEntity` callback (selects nodes/edges on canvas), `ActivityHistorySidebar` import and rendering inside the canvas area, `onHistory` toggle prop on Toolbar +- **Learnings for future iterations:** + - React Compiler lint (`react-hooks/set-state-in-effect`) treats any function that calls setState as problematic when invoked inside useEffect — even if the setState is in an async `.then()` callback. To avoid this, extract data fetching into a pure function that returns a result object, then handle setState only in the `.then()` callback after checking a mounted/aborted guard. + - For right sidebar panels overlaying the canvas, use `absolute right-0 top-0 z-40 h-full w-80` inside the `relative flex-1` canvas container. This keeps the sidebar within the canvas area without affecting the toolbar. + - The `audit_trail` table has an index on `(project_id, created_at DESC)` which makes paginated queries efficient. Use `.range(offset, offset + PAGE_SIZE - 1)` for Supabase pagination. + - Entity descriptions are derived from `new_state` (for adds/updates) or `previous_state` (for deletes). The state contains the full node/edge data including `type`, `data.speaker`, `data.question`, `data.variableName`. + - Deleted entities (`action_type.endsWith('_delete')`) cannot be selected on canvas since they no longer exist — render those entries as disabled (no click handler, reduced opacity). + - No browser testing tools are available; manual verification is needed. +--- + +## 2026-01-24 - US-053 +- What was implemented: Revert changes from audit trail — each history entry has a Revert button, confirmation dialog with before/after preview, and revert logic that reverses node/edge add/update/delete operations +- Files changed: + - `src/components/editor/RevertConfirmDialog.tsx` - New component: confirmation dialog showing action description, before/after state previews, with Cancel and Revert buttons + - `src/components/editor/ActivityHistorySidebar.tsx` - Added Revert button (shows on hover per entry), `revertEntry` state, `RevertConfirmDialog` rendering, exported `AuditEntry` type, added `onRevert` prop + - `src/app/editor/[projectId]/FlowchartEditor.tsx` - Added `handleRevertEntry` callback implementing all revert cases (node add→delete, node update→restore, node delete→recreate, same for edges), `isRevertingRef` to prevent double audit recording, `getRevertActionType` helper, explicit audit trail write for the revert itself, toast notification on success +- **Learnings for future iterations:** + - Reverting uses the same `setNodes`/`setEdges` state setters, so CRDT sync happens automatically through the existing effects that watch `nodesForCRDT`/`edgesForCRDT` — no explicit CRDT call needed. + - To prevent double audit recording (once from the sync effect, once from the explicit revert write), use an `isRevertingRef` guard set synchronously before `setNodes`/`setEdges` and cleared with `setTimeout(() => ..., 0)` after React processes the state updates. + - The revert audit entry uses inverse action types: reverting `node_add` records `node_delete`, reverting `node_delete` records `node_add`, `node_update` stays `node_update`. + - The `previous_state` and `new_state` are swapped for the revert audit entry: what was `new_state` (the current state being reverted) becomes `previous_state`, and what was `previous_state` (the state being restored) becomes `new_state`. + - Reverting a `node_add` also removes connected edges to prevent dangling edge references. + - The RevertConfirmDialog uses `z-[70]` to layer above the ActivityHistorySidebar (`z-40`). + - The Revert button uses CSS `group-hover:inline-block` pattern to appear only on entry hover, keeping the UI clean. + - No browser testing tools are available; manual verification is needed. +--- diff --git a/src/app/editor/[projectId]/FlowchartEditor.tsx b/src/app/editor/[projectId]/FlowchartEditor.tsx index 9f938d5..d134a63 100644 --- a/src/app/editor/[projectId]/FlowchartEditor.tsx +++ b/src/app/editor/[projectId]/FlowchartEditor.tsx @@ -33,16 +33,21 @@ import ProjectSettingsModal from '@/components/editor/ProjectSettingsModal' import ConditionEditor from '@/components/editor/ConditionEditor' import ExportValidationModal, { type ValidationIssue } from '@/components/editor/ExportValidationModal' import { EditorProvider } from '@/components/editor/EditorContext' -import { RealtimeConnection, type ConnectionState, type PresenceUser } from '@/lib/collaboration/realtime' +import { RealtimeConnection, type ConnectionState, type PresenceUser, type RemoteCursor, type NodeLock } from '@/lib/collaboration/realtime' +import type { NodeLockInfo } from '@/components/editor/EditorContext' +import RemoteCursors from '@/components/editor/RemoteCursors' import { CRDTManager } from '@/lib/collaboration/crdt' +import { AuditTrailRecorder } from '@/lib/collaboration/auditTrail' import ShareModal from '@/components/editor/ShareModal' +import ActivityHistorySidebar, { type AuditEntry } from '@/components/editor/ActivityHistorySidebar' +import CollaborationToast, { type CollaborationNotification } from '@/components/editor/CollaborationToast' import type { FlowchartData, FlowchartNode, FlowchartEdge, Character, Variable, Condition } from '@/types/flowchart' // LocalStorage key prefix for draft saves const DRAFT_KEY_PREFIX = 'vnwrite-draft-' -// Debounce delay in ms -const AUTOSAVE_DEBOUNCE_MS = 1000 +// Debounce delay for LocalStorage draft saves +const AUTOSAVE_DEBOUNCE_MS = 5000 type ContextMenuState = { x: number @@ -302,6 +307,28 @@ function randomHexColor(): string { return RANDOM_COLORS[Math.floor(Math.random() * RANDOM_COLORS.length)] } +// Generate a consistent color from a user ID hash (same logic as PresenceAvatars) +function getUserColor(userId: string): string { + let hash = 0 + for (let i = 0; i < userId.length; i++) { + hash = ((hash << 5) - hash + userId.charCodeAt(i)) | 0 + } + return RANDOM_COLORS[Math.abs(hash) % RANDOM_COLORS.length] +} + +// Determine the action type for a revert audit entry +function getRevertActionType(originalActionType: string): string { + switch (originalActionType) { + case 'node_add': return 'node_delete' // reverting an add = deleting + case 'node_delete': return 'node_add' // reverting a delete = adding back + case 'node_update': return 'node_update' // reverting an update = updating back + case 'edge_add': return 'edge_delete' + case 'edge_delete': return 'edge_add' + case 'edge_update': return 'edge_update' + default: return originalActionType + } +} + // Compute auto-migration of existing free-text values to character/variable definitions function computeMigration(initialData: FlowchartData, shouldMigrate: boolean) { if (!shouldMigrate) { @@ -500,17 +527,31 @@ function FlowchartEditorInner({ projectId, projectName, userId, userDisplayName, const [characters, setCharacters] = useState(migratedData.characters) const [variables, setVariables] = useState(migratedData.variables) + + // Refs to always have the latest characters/variables for the CRDT persist callback + const charactersRef = useRef(characters) + const variablesRef = useRef(variables) + charactersRef.current = characters + variablesRef.current = variables const [showSettings, setShowSettings] = useState(false) const [showShare, setShowShare] = useState(false) + const [showHistory, setShowHistory] = useState(false) const [selectedEdgeId, setSelectedEdgeId] = useState(null) const [toastMessage, setToastMessage] = useState(migratedData.toastMessage) const [validationIssues, setValidationIssues] = useState(null) const [warningNodeIds, setWarningNodeIds] = useState>(new Set()) const [connectionState, setConnectionState] = useState('disconnected') const [presenceUsers, setPresenceUsers] = useState([]) + const [remoteCursors, setRemoteCursors] = useState([]) const realtimeRef = useRef(null) const crdtRef = useRef(null) - const isRemoteUpdateRef = useRef(false) + const auditRef = useRef(null) + const cursorThrottleRef = useRef(0) + const [collaborationNotifications, setCollaborationNotifications] = useState([]) + const [nodeLocks, setNodeLocks] = useState>(new Map()) + const localLockRef = useRef(null) // node ID currently locked by this user + const lockExpiryTimerRef = useRef | null>(null) + const isRevertingRef = useRef(false) // guards against double audit recording during revert // Initialize CRDT manager and connect to Supabase Realtime channel on mount useEffect(() => { @@ -518,25 +559,26 @@ function FlowchartEditorInner({ projectId, projectName, userId, userDisplayName, const crdtManager = new CRDTManager({ onNodesChange: (crdtNodes: FlowchartNode[]) => { - isRemoteUpdateRef.current = true setNodes(toReactFlowNodes(crdtNodes)) - isRemoteUpdateRef.current = false }, onEdgesChange: (crdtEdges: FlowchartEdge[]) => { - isRemoteUpdateRef.current = true setEdges(toReactFlowEdges(crdtEdges)) - isRemoteUpdateRef.current = false }, onPersist: async (persistNodes: FlowchartNode[], persistEdges: FlowchartEdge[]) => { try { + // Auto-persist saves the current state for durability. We do NOT + // broadcast state-refresh here because CRDT already syncs nodes/edges + // via yjs-update broadcasts. Broadcasting here causes ping-pong: + // other clients fetch from DB, overwrite their local variables/characters, + // then their persist writes stale data back, causing a loop. await supabase .from('projects') .update({ flowchart_data: { nodes: persistNodes, edges: persistEdges, - characters, - variables, + characters: charactersRef.current, + variables: variablesRef.current, }, }) .eq('id', projectId) @@ -550,9 +592,78 @@ function FlowchartEditorInner({ projectId, projectName, userId, userDisplayName, crdtManager.initializeFromData(migratedData.nodes, migratedData.edges) crdtRef.current = crdtManager + // Initialize audit trail recorder + const auditRecorder = new AuditTrailRecorder(projectId, userId) + auditRecorder.initialize(migratedData.nodes, migratedData.edges) + auditRef.current = auditRecorder + const connection = new RealtimeConnection(projectId, userId, userDisplayName, { onConnectionStateChange: setConnectionState, onPresenceSync: setPresenceUsers, + onPresenceJoin: (user) => { + setCollaborationNotifications((prev) => [ + ...prev, + { id: nanoid(), displayName: user.displayName, type: 'join', color: getUserColor(user.userId) }, + ]) + // Send full CRDT state so the joining client gets caught up + crdtManager.broadcastFullState() + }, + onPresenceLeave: (user) => { + setCollaborationNotifications((prev) => [ + ...prev, + { id: nanoid(), displayName: user.displayName, type: 'leave', color: getUserColor(user.userId) }, + ]) + }, + onCursorUpdate: (cursor) => { + setRemoteCursors((prev) => { + const existing = prev.findIndex((c) => c.userId === cursor.userId) + if (existing >= 0) { + const updated = [...prev] + updated[existing] = cursor + return updated + } + return [...prev, cursor] + }) + }, + onNodeLockUpdate: (lock: NodeLock | null, lockUserId: string) => { + setNodeLocks((prev) => { + const next = new Map(prev) + if (lock) { + next.set(lock.nodeId, { ...lock, color: getUserColor(lock.userId) }) + } else { + // Remove any lock held by this user + for (const [nodeId, info] of next) { + if (info.userId === lockUserId) { + next.delete(nodeId) + } + } + } + return next + }) + }, + onCRDTUpdate: (update: number[]) => { + crdtManager.applyRemoteUpdate(update) + }, + onStateRefresh: async () => { + try { + const sb = createClient() + const { data } = await sb + .from('projects') + .select('flowchart_data') + .eq('id', projectId) + .single() + if (data?.flowchart_data) { + const fd = data.flowchart_data as FlowchartData + setNodes(toReactFlowNodes(fd.nodes)) + setEdges(toReactFlowEdges(fd.edges)) + setCharacters(fd.characters) + setVariables(fd.variables) + crdtManager.refreshFromData(fd.nodes, fd.edges) + } + } catch { + // Non-critical: user can still manually refresh + } + }, onChannelSubscribed: (channel) => { crdtManager.connectChannel(channel) }, @@ -561,14 +672,53 @@ function FlowchartEditorInner({ projectId, projectName, userId, userDisplayName, connection.connect() return () => { + // Release any held lock before disconnecting + if (localLockRef.current) { + connection.broadcastNodeLock(null) + localLockRef.current = null + } connection.disconnect() realtimeRef.current = null crdtManager.destroy() crdtRef.current = null + auditRecorder.destroy() + auditRef.current = null } // eslint-disable-next-line react-hooks/exhaustive-deps }, [projectId, userId, userDisplayName]) + // Manage connection lifecycle based on visibility and user activity + useEffect(() => { + const handleVisibilityChange = () => { + if (!document.hidden) { + realtimeRef.current?.notifyVisibilityResumed() + } + } + + // Throttle activity notifications to avoid excessive calls + let activityThrottled = false + const throttledActivity = () => { + if (activityThrottled) return + activityThrottled = true + realtimeRef.current?.notifyActivity() + setTimeout(() => { activityThrottled = false }, 10_000) + } + + document.addEventListener('visibilitychange', handleVisibilityChange) + document.addEventListener('mousedown', throttledActivity) + document.addEventListener('keydown', throttledActivity) + document.addEventListener('scroll', throttledActivity, true) + document.addEventListener('mousemove', throttledActivity) + + return () => { + document.removeEventListener('visibilitychange', handleVisibilityChange) + document.removeEventListener('mousedown', throttledActivity) + document.removeEventListener('keydown', throttledActivity) + document.removeEventListener('scroll', throttledActivity, true) + document.removeEventListener('mousemove', throttledActivity) + } + }, []) + // Sync local React Flow state changes to CRDT (skip remote-originated updates) const nodesForCRDT = useMemo(() => { return nodes.map((node) => ({ @@ -591,15 +741,223 @@ function FlowchartEditorInner({ projectId, projectName, userId, userDisplayName, }, [edges]) useEffect(() => { - if (isRemoteUpdateRef.current) return crdtRef.current?.updateNodes(nodesForCRDT) + if (!isRevertingRef.current) { + auditRef.current?.recordNodeChanges(nodesForCRDT) + } }, [nodesForCRDT]) useEffect(() => { - if (isRemoteUpdateRef.current) return crdtRef.current?.updateEdges(edgesForCRDT) + if (!isRevertingRef.current) { + auditRef.current?.recordEdgeChanges(edgesForCRDT) + } }, [edgesForCRDT]) + // Broadcast cursor position on mouse move (throttled to 50ms) + const handleMouseMove = useCallback( + (event: React.MouseEvent) => { + const now = Date.now() + if (now - cursorThrottleRef.current < 50) return + cursorThrottleRef.current = now + + const connection = realtimeRef.current + if (!connection) return + + // Convert screen position to flow coordinates + const bounds = event.currentTarget.getBoundingClientRect() + const screenX = event.clientX - bounds.left + const screenY = event.clientY - bounds.top + const flowPosition = screenToFlowPosition({ x: screenX, y: screenY }) + + connection.broadcastCursor(flowPosition) + }, + [screenToFlowPosition] + ) + + // Remove cursors and locks for users who leave + useEffect(() => { + setRemoteCursors((prev) => + prev.filter((cursor) => + presenceUsers.some((u) => u.userId === cursor.userId) + ) + ) + setNodeLocks((prev) => { + const next = new Map(prev) + let changed = false + for (const [nodeId, info] of next) { + if (!presenceUsers.some((u) => u.userId === info.userId)) { + next.delete(nodeId) + changed = true + } + } + return changed ? next : prev + }) + }, [presenceUsers]) + + // Lock auto-expiry: expire locks after 60 seconds of inactivity + useEffect(() => { + const LOCK_EXPIRY_MS = 60_000 + lockExpiryTimerRef.current = setInterval(() => { + const now = Date.now() + setNodeLocks((prev) => { + const next = new Map(prev) + let changed = false + for (const [nodeId, info] of next) { + if (now - info.lockedAt > LOCK_EXPIRY_MS) { + next.delete(nodeId) + changed = true + } + } + return changed ? next : prev + }) + }, 5000) // Check every 5 seconds + + return () => { + if (lockExpiryTimerRef.current) { + clearInterval(lockExpiryTimerRef.current) + lockExpiryTimerRef.current = null + } + } + }, []) + + const handleDismissNotification = useCallback((id: string) => { + setCollaborationNotifications((prev) => prev.filter((n) => n.id !== id)) + }, []) + + const handleHistorySelectEntity = useCallback((entityId: string, actionType: string) => { + if (actionType.startsWith('node_')) { + // Select the node on the canvas + setNodes((nds) => + nds.map((n) => ({ ...n, selected: n.id === entityId })) + ) + setEdges((eds) => + eds.map((e) => ({ ...e, selected: false })) + ) + } else if (actionType.startsWith('edge_')) { + // Select the edge on the canvas + setEdges((eds) => + eds.map((e) => ({ ...e, selected: e.id === entityId })) + ) + setNodes((nds) => + nds.map((n) => ({ ...n, selected: false })) + ) + } + }, [setNodes, setEdges]) + + const handleRevertEntry = useCallback((entry: AuditEntry) => { + const { action_type, entity_id, previous_state, new_state } = entry + + // Guard against double audit recording - we write our own audit entry for the revert + isRevertingRef.current = true + // Reset after React has processed the state updates + setTimeout(() => { isRevertingRef.current = false }, 0) + + if (action_type === 'node_add') { + // Revert an addition = delete the node + setNodes((nds) => nds.filter((n) => n.id !== entity_id)) + // Also remove any edges connected to this node + setEdges((eds) => eds.filter((e) => e.source !== entity_id && e.target !== entity_id)) + } else if (action_type === 'node_update') { + // Revert an update = restore previous state + if (previous_state) { + const prevNode = previous_state as unknown as FlowchartNode + setNodes((nds) => + nds.map((n) => + n.id === entity_id + ? { ...n, position: prevNode.position, data: prevNode.data } + : n + ) + ) + } + } else if (action_type === 'node_delete') { + // Revert a deletion = re-create the node from previous_state + if (previous_state) { + const prevNode = previous_state as unknown as FlowchartNode + const newReactFlowNode: Node = { + id: prevNode.id, + type: prevNode.type, + position: prevNode.position, + data: prevNode.data, + } + setNodes((nds) => [...nds, newReactFlowNode]) + } + } else if (action_type === 'edge_add') { + // Revert an edge addition = delete the edge + setEdges((eds) => eds.filter((e) => e.id !== entity_id)) + } else if (action_type === 'edge_update') { + // Revert an edge update = restore previous state + if (previous_state) { + const prevEdge = previous_state as unknown as FlowchartEdge + setEdges((eds) => + eds.map((e) => + e.id === entity_id + ? { + ...e, + source: prevEdge.source, + sourceHandle: prevEdge.sourceHandle, + target: prevEdge.target, + targetHandle: prevEdge.targetHandle, + data: prevEdge.data, + } + : e + ) + ) + } + } else if (action_type === 'edge_delete') { + // Revert an edge deletion = re-create the edge from previous_state + if (previous_state) { + const prevEdge = previous_state as unknown as FlowchartEdge + const newReactFlowEdge: Edge = { + id: prevEdge.id, + source: prevEdge.source, + sourceHandle: prevEdge.sourceHandle, + target: prevEdge.target, + targetHandle: prevEdge.targetHandle, + data: prevEdge.data, + type: 'conditional', + markerEnd: { type: MarkerType.ArrowClosed }, + } + setEdges((eds) => [...eds, newReactFlowEdge]) + } + } + + // Record the revert as a new audit trail entry (fire-and-forget) + const supabase = createClient() + const revertActionType = getRevertActionType(action_type) + supabase + .from('audit_trail') + .insert({ + project_id: projectId, + user_id: userId, + action_type: revertActionType, + entity_id, + previous_state: new_state, // "previous" for the revert is the current state (which was new_state) + new_state: previous_state, // "new" for the revert is what we're restoring to + }) + .then(({ error }) => { + if (error) { + console.error('[Revert] Failed to write revert audit entry:', error) + } + }) + + setToast({ message: 'Change reverted successfully', type: 'success' }) + }, [setNodes, setEdges, projectId, userId]) + + const handleNodeFocus = useCallback((nodeId: string) => { + // Broadcast lock for this node + localLockRef.current = nodeId + realtimeRef.current?.broadcastNodeLock(nodeId) + }, []) + + const handleNodeBlur = useCallback(() => { + // Release lock + if (localLockRef.current) { + localLockRef.current = null + realtimeRef.current?.broadcastNodeLock(null) + } + }, []) + const handleAddCharacter = useCallback( (name: string, color: string): string => { const id = nanoid() @@ -621,8 +979,16 @@ function FlowchartEditorInner({ projectId, projectName, userId, userDisplayName, ) const editorContextValue = useMemo( - () => ({ characters, onAddCharacter: handleAddCharacter, variables, onAddVariable: handleAddVariableDefinition }), - [characters, handleAddCharacter, variables, handleAddVariableDefinition] + () => ({ + characters, + onAddCharacter: handleAddCharacter, + variables, + onAddVariable: handleAddVariableDefinition, + nodeLocks, + onNodeFocus: handleNodeFocus, + onNodeBlur: handleNodeBlur, + }), + [characters, handleAddCharacter, variables, handleAddVariableDefinition, nodeLocks, handleNodeFocus, handleNodeBlur] ) const getCharacterUsageCount = useCallback( @@ -836,6 +1202,9 @@ function FlowchartEditorInner({ projectId, projectName, userId, userDisplayName, // Update last saved data ref to mark as not dirty lastSavedDataRef.current = flowchartData + // Notify other connected clients to refresh from the database + realtimeRef.current?.broadcastStateRefresh() + setToast({ message: 'Project saved successfully', type: 'success' }) } catch (error) { console.error('Failed to save project:', error) @@ -1207,10 +1576,11 @@ function FlowchartEditorInner({ projectId, projectName, userId, userDisplayName, onImport={handleImport} onProjectSettings={() => setShowSettings(true)} onShare={() => setShowShare(true)} + onHistory={() => setShowHistory((v) => !v)} connectionState={connectionState} presenceUsers={presenceUsers} /> -
+
+ + {showHistory && ( + setShowHistory(false)} + onSelectEntity={handleHistorySelectEntity} + onRevert={handleRevertEntry} + /> + )}
{contextMenu && ( setToastMessage(null)} /> )} + {collaborationNotifications.length > 0 && ( +
+ {collaborationNotifications.map((notification) => ( + + ))} +
+ )}
) diff --git a/src/app/editor/[projectId]/page.tsx b/src/app/editor/[projectId]/page.tsx index c5511e8..7573003 100644 --- a/src/app/editor/[projectId]/page.tsx +++ b/src/app/editor/[projectId]/page.tsx @@ -41,7 +41,6 @@ export default async function EditorPage({ params }: PageProps) { // If not the owner, check if the user is a collaborator if (!project) { - // RLS on projects allows collaborators to SELECT shared projects const { data: collab } = await supabase .from('project_collaborators') .select('id, role') @@ -49,58 +48,42 @@ export default async function EditorPage({ params }: PageProps) { .eq('user_id', user.id) .single() - if (!collab) { - notFound() + if (collab) { + const { data: sharedProject } = await supabase + .from('projects') + .select('id, name, flowchart_data') + .eq('id', projectId) + .single() + + project = sharedProject + isOwner = false } - - const { data: sharedProject } = await supabase - .from('projects') - .select('id, name, flowchart_data') - .eq('id', projectId) - .single() - - if (!sharedProject) { - notFound() - } - - project = sharedProject - isOwner = false } - const rawData = project.flowchart_data || {} - const flowchartData: FlowchartData = { - nodes: rawData.nodes || [], - edges: rawData.edges || [], - characters: rawData.characters || [], - variables: rawData.variables || [], - } - - // Migration flag: if the raw data doesn't have characters/variables arrays, - // the project was created before these features existed and may need auto-migration - const needsMigration = !rawData.characters && !rawData.variables - - return (<> -
-
-
- - +
+
+ - - - + + + + +
@@ -131,32 +114,31 @@ export default async function EditorPage({ params }: PageProps) {
- - -
-
- ) } - const flowchartData = (project.flowchart_data || { - nodes: [], - edges: [], - }) as FlowchartData + const rawData = project.flowchart_data || {} + const flowchartData: FlowchartData = { + nodes: rawData.nodes || [], + edges: rawData.edges || [], + characters: rawData.characters || [], + variables: rawData.variables || [], + } + + // Migration flag: if the raw data doesn't have characters/variables arrays, + // the project was created before these features existed and may need auto-migration + const needsMigration = !rawData.characters && !rawData.variables return ( ) } diff --git a/src/components/editor/ActivityHistorySidebar.tsx b/src/components/editor/ActivityHistorySidebar.tsx new file mode 100644 index 0000000..3649428 --- /dev/null +++ b/src/components/editor/ActivityHistorySidebar.tsx @@ -0,0 +1,357 @@ +'use client' + +import { useCallback, useEffect, useRef, useState } from 'react' +import { createClient } from '@/lib/supabase/client' +import RevertConfirmDialog from './RevertConfirmDialog' + +const PAGE_SIZE = 20 + +export type AuditEntry = { + id: string + project_id: string + user_id: string + action_type: string + entity_id: string + previous_state: Record | null + new_state: Record | null + created_at: string + user_display_name?: string +} + +type ActivityHistorySidebarProps = { + projectId: string + onClose: () => void + onSelectEntity: (entityId: string, actionType: string) => void + onRevert: (entry: AuditEntry) => void +} + +const ACTION_LABELS: Record = { + node_add: 'Added node', + node_update: 'Updated node', + node_delete: 'Deleted node', + edge_add: 'Added edge', + edge_update: 'Updated edge', + edge_delete: 'Deleted edge', +} + +const ACTION_ICONS: Record = { + node_add: '+', + node_update: '~', + node_delete: '-', + edge_add: '+', + edge_update: '~', + edge_delete: '-', +} + +const ACTION_COLORS: Record = { + node_add: 'text-green-500', + node_update: 'text-blue-500', + node_delete: 'text-red-500', + edge_add: 'text-green-500', + edge_update: 'text-blue-500', + edge_delete: 'text-red-500', +} + +// Same hash logic as PresenceAvatars and FlowchartEditor +const PRESENCE_COLORS = [ + '#EF4444', '#F97316', '#F59E0B', '#10B981', + '#3B82F6', '#8B5CF6', '#EC4899', '#14B8A6', + '#6366F1', '#F43F5E', '#84CC16', '#06B6D4', +] + +function getUserColor(userId: string): string { + let hash = 0 + for (let i = 0; i < userId.length; i++) { + hash = ((hash << 5) - hash + userId.charCodeAt(i)) | 0 + } + return PRESENCE_COLORS[Math.abs(hash) % PRESENCE_COLORS.length] +} + +function getEntityDescription(entry: AuditEntry): string { + const state = entry.new_state || entry.previous_state + if (!state) return entry.entity_id.slice(0, 8) + + if (entry.action_type.startsWith('node_')) { + const type = (state as Record).type as string | undefined + const data = (state as Record).data as Record | undefined + if (type === 'dialogue' && data) { + const speaker = (data.speaker as string) || (data.characterId as string) || '' + return speaker ? `Dialogue (${speaker})` : 'Dialogue node' + } + if (type === 'choice' && data) { + const question = (data.question as string) || '' + return question ? `Choice: "${question.slice(0, 20)}${question.length > 20 ? '…' : ''}"` : 'Choice node' + } + if (type === 'variable' && data) { + const name = (data.variableName as string) || '' + return name ? `Variable: ${name}` : 'Variable node' + } + return `${type || 'Unknown'} node` + } + + // Edge entries + return 'Connection' +} + +function formatTime(dateStr: string): string { + const date = new Date(dateStr) + return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) +} + +function getTimePeriod(dateStr: string): 'Today' | 'Yesterday' | 'Earlier' { + const date = new Date(dateStr) + const now = new Date() + const today = new Date(now.getFullYear(), now.getMonth(), now.getDate()) + const yesterday = new Date(today) + yesterday.setDate(yesterday.getDate() - 1) + + if (date >= today) return 'Today' + if (date >= yesterday) return 'Yesterday' + return 'Earlier' +} + +type GroupedEntries = { + period: 'Today' | 'Yesterday' | 'Earlier' + entries: AuditEntry[] +} + +function groupByPeriod(entries: AuditEntry[]): GroupedEntries[] { + const groups: Record = {} + const order: ('Today' | 'Yesterday' | 'Earlier')[] = ['Today', 'Yesterday', 'Earlier'] + + for (const entry of entries) { + const period = getTimePeriod(entry.created_at) + if (!groups[period]) groups[period] = [] + groups[period].push(entry) + } + + return order + .filter((p) => groups[p] && groups[p].length > 0) + .map((p) => ({ period: p, entries: groups[p] })) +} + +export default function ActivityHistorySidebar({ + projectId, + onClose, + onSelectEntity, + onRevert, +}: ActivityHistorySidebarProps) { + const [entries, setEntries] = useState([]) + const [loading, setLoading] = useState(true) + const [loadingMore, setLoadingMore] = useState(false) + const [hasMore, setHasMore] = useState(true) + const [error, setError] = useState(null) + const [revertEntry, setRevertEntry] = useState(null) + const mountedRef = useRef(true) + + const fetchEntriesRaw = useCallback(async (offset: number): Promise<{ entries: AuditEntry[]; hasMore: boolean; error?: string }> => { + const supabase = createClient() + const { data, error: fetchError } = await supabase + .from('audit_trail') + .select('id, project_id, user_id, action_type, entity_id, previous_state, new_state, created_at') + .eq('project_id', projectId) + .order('created_at', { ascending: false }) + .range(offset, offset + PAGE_SIZE - 1) + + if (fetchError) { + return { entries: [], hasMore: false, error: fetchError.message } + } + + const moreAvailable = !!data && data.length >= PAGE_SIZE + + // Fetch user display names for the entries + if (data && data.length > 0) { + const userIds = [...new Set(data.map((e) => e.user_id))] + const { data: profiles } = await supabase + .from('profiles') + .select('id, display_name') + .in('id', userIds) + + const nameMap = new Map() + if (profiles) { + for (const p of profiles) { + nameMap.set(p.id, p.display_name || 'Unknown') + } + } + + return { + entries: data.map((e) => ({ + ...e, + user_display_name: nameMap.get(e.user_id) || 'Unknown', + })), + hasMore: moreAvailable, + } + } + + return { entries: data || [], hasMore: moreAvailable } + }, [projectId]) + + useEffect(() => { + mountedRef.current = true + const controller = new AbortController() + fetchEntriesRaw(0).then((result) => { + if (!controller.signal.aborted && mountedRef.current) { + if (result.error) { + setError(result.error) + } else { + setEntries(result.entries) + setHasMore(result.hasMore) + } + setLoading(false) + } + }) + return () => { + controller.abort() + mountedRef.current = false + } + }, [fetchEntriesRaw]) + + const handleLoadMore = async () => { + setLoadingMore(true) + const result = await fetchEntriesRaw(entries.length) + if (result.error) { + setError(result.error) + } else { + setEntries((prev) => [...prev, ...result.entries]) + setHasMore(result.hasMore) + } + setLoadingMore(false) + } + + const grouped = groupByPeriod(entries) + + return ( +
+
+

+ Activity History +

+ +
+ +
+ {loading && ( +
+ + + + +
+ )} + + {error && ( +
+ Failed to load history: {error} +
+ )} + + {!loading && !error && entries.length === 0 && ( +
+ No activity recorded yet +
+ )} + + {!loading && grouped.map((group) => ( +
+
+
+ {group.period} +
+
+
+ {group.entries.map((entry) => { + const userColor = getUserColor(entry.user_id) + const isDeleted = entry.action_type.endsWith('_delete') + return ( +
+
+
+
+
+ + {ACTION_ICONS[entry.action_type] || '?'} + + +
+
+ {getEntityDescription(entry)} +
+
+
+ {entry.user_display_name} + · + {formatTime(entry.created_at)} +
+ +
+
+
+
+ ) + })} +
+
+ ))} + + {!loading && hasMore && entries.length > 0 && ( +
+ +
+ )} +
+ {revertEntry && ( + { + onRevert(revertEntry) + setRevertEntry(null) + }} + onCancel={() => setRevertEntry(null)} + /> + )} +
+ ) +} diff --git a/src/components/editor/CollaborationToast.tsx b/src/components/editor/CollaborationToast.tsx new file mode 100644 index 0000000..3885d9c --- /dev/null +++ b/src/components/editor/CollaborationToast.tsx @@ -0,0 +1,43 @@ +'use client' + +import { useEffect } from 'react' + +export type CollaborationNotification = { + id: string + displayName: string + type: 'join' | 'leave' + color: string +} + +type CollaborationToastProps = { + notification: CollaborationNotification + onDismiss: (id: string) => void +} + +export default function CollaborationToast({ notification, onDismiss }: CollaborationToastProps) { + useEffect(() => { + const timer = setTimeout(() => { + onDismiss(notification.id) + }, 3000) + + return () => clearTimeout(timer) + }, [notification.id, onDismiss]) + + const message = notification.type === 'join' + ? `${notification.displayName} joined` + : `${notification.displayName} left` + + return ( +
+
+
+ {message} +
+
+ ) +} diff --git a/src/components/editor/EditorContext.tsx b/src/components/editor/EditorContext.tsx index 39a921d..177c119 100644 --- a/src/components/editor/EditorContext.tsx +++ b/src/components/editor/EditorContext.tsx @@ -2,12 +2,18 @@ import { createContext, useContext } from 'react' import type { Character, Variable } from '@/types/flowchart' +import type { NodeLock } from '@/lib/collaboration/realtime' + +export type NodeLockInfo = NodeLock & { color: string } type EditorContextValue = { characters: Character[] onAddCharacter: (name: string, color: string) => string // returns new character id variables: Variable[] onAddVariable: (name: string, type: 'numeric' | 'string' | 'boolean', initialValue: number | string | boolean) => string // returns new variable id + nodeLocks: Map // nodeId -> lock info + onNodeFocus: (nodeId: string) => void + onNodeBlur: () => void } const EditorContext = createContext({ @@ -15,6 +21,9 @@ const EditorContext = createContext({ onAddCharacter: () => '', variables: [], onAddVariable: () => '', + nodeLocks: new Map(), + onNodeFocus: () => {}, + onNodeBlur: () => {}, }) export const EditorProvider = EditorContext.Provider diff --git a/src/components/editor/NodeLockIndicator.tsx b/src/components/editor/NodeLockIndicator.tsx new file mode 100644 index 0000000..8cde517 --- /dev/null +++ b/src/components/editor/NodeLockIndicator.tsx @@ -0,0 +1,24 @@ +'use client' + +import type { NodeLock } from '@/lib/collaboration/realtime' + +type NodeLockIndicatorProps = { + lock: NodeLock + color: string +} + +export default function NodeLockIndicator({ lock, color }: NodeLockIndicatorProps) { + return ( +
+
+ {lock.displayName} +
+
+ ) +} diff --git a/src/components/editor/RemoteCursors.tsx b/src/components/editor/RemoteCursors.tsx new file mode 100644 index 0000000..86825dd --- /dev/null +++ b/src/components/editor/RemoteCursors.tsx @@ -0,0 +1,95 @@ +'use client' + +import { useEffect, useState } from 'react' +import { useViewport } from 'reactflow' +import type { RemoteCursor } from '@/lib/collaboration/realtime' + +type RemoteCursorsProps = { + cursors: RemoteCursor[] +} + +const FADE_TIMEOUT_MS = 5000 + +// Generate a consistent color from a user ID hash (same algorithm as PresenceAvatars) +function getUserColor(userId: string): string { + let hash = 0 + for (let i = 0; i < userId.length; i++) { + hash = ((hash << 5) - hash + userId.charCodeAt(i)) | 0 + } + const colors = [ + '#EF4444', '#F97316', '#F59E0B', '#10B981', + '#3B82F6', '#8B5CF6', '#EC4899', '#14B8A6', + '#6366F1', '#F43F5E', '#84CC16', '#06B6D4', + ] + return colors[Math.abs(hash) % colors.length] +} + +export default function RemoteCursors({ cursors }: RemoteCursorsProps) { + const viewport = useViewport() + const [now, setNow] = useState(() => Date.now()) + + // Tick every second to update fade states + useEffect(() => { + const timer = setInterval(() => setNow(Date.now()), 1000) + return () => clearInterval(timer) + }, []) + + return ( +
+ {cursors.map((cursor) => { + const timeSinceUpdate = now - cursor.lastUpdated + const isFaded = timeSinceUpdate > FADE_TIMEOUT_MS + if (isFaded) return null + + const opacity = timeSinceUpdate > FADE_TIMEOUT_MS - 1000 + ? Math.max(0, 1 - (timeSinceUpdate - (FADE_TIMEOUT_MS - 1000)) / 1000) + : 1 + + // Convert flow coordinates to screen coordinates + const screenX = cursor.position.x * viewport.zoom + viewport.x + const screenY = cursor.position.y * viewport.zoom + viewport.y + + const color = getUserColor(cursor.userId) + + return ( +
+ {/* Cursor arrow SVG */} + + + + + {/* User name label */} +
+ {cursor.displayName} +
+
+ ) + })} +
+ ) +} diff --git a/src/components/editor/RevertConfirmDialog.tsx b/src/components/editor/RevertConfirmDialog.tsx new file mode 100644 index 0000000..54cdc1f --- /dev/null +++ b/src/components/editor/RevertConfirmDialog.tsx @@ -0,0 +1,162 @@ +'use client' + +type RevertConfirmDialogProps = { + actionType: string + entityDescription: string + previousState: Record | null + newState: Record | null + onConfirm: () => void + onCancel: () => void +} + +const ACTION_LABELS: Record = { + node_add: 'node addition', + node_update: 'node update', + node_delete: 'node deletion', + edge_add: 'edge addition', + edge_update: 'edge update', + edge_delete: 'edge deletion', +} + +function formatStatePreview(state: Record | null): string { + if (!state) return '(none)' + + const type = state.type as string | undefined + const data = state.data as Record | undefined + + if (type === 'dialogue' && data) { + const speaker = (data.speaker as string) || '(no speaker)' + const text = (data.text as string) || '(no text)' + return `Dialogue: ${speaker}\n"${text.slice(0, 80)}${text.length > 80 ? '…' : ''}"` + } + if (type === 'choice' && data) { + const prompt = (data.prompt as string) || '(no prompt)' + const options = (data.options as { label: string }[]) || [] + const optionLabels = options.map((o) => o.label || '(empty)').join(', ') + return `Choice: ${prompt.slice(0, 60)}${prompt.length > 60 ? '…' : ''}\nOptions: ${optionLabels}` + } + if (type === 'variable' && data) { + const name = (data.variableName as string) || '(unnamed)' + const op = (data.operation as string) || 'set' + const val = data.value ?? 0 + return `Variable: ${name} ${op} ${val}` + } + + // Edge state + if (state.source && state.target) { + const condition = (state.data as Record | undefined)?.condition as Record | undefined + if (condition) { + return `Edge: ${state.source} → ${state.target}\nCondition: ${condition.variableName} ${condition.operator} ${condition.value}` + } + return `Edge: ${state.source} → ${state.target}` + } + + return JSON.stringify(state, null, 2).slice(0, 200) +} + +function getRevertDescription(actionType: string): string { + switch (actionType) { + case 'node_add': + return 'This will delete the node that was added.' + case 'node_update': + return 'This will restore the node to its previous state.' + case 'node_delete': + return 'This will re-create the deleted node.' + case 'edge_add': + return 'This will delete the edge that was added.' + case 'edge_update': + return 'This will restore the edge to its previous state.' + case 'edge_delete': + return 'This will re-create the deleted edge.' + default: + return 'This will undo the change.' + } +} + +export default function RevertConfirmDialog({ + actionType, + entityDescription, + previousState, + newState, + onConfirm, + onCancel, +}: RevertConfirmDialogProps) { + const label = ACTION_LABELS[actionType] || actionType + const description = getRevertDescription(actionType) + + // For revert, the "before" is the current state (newState) and "after" is what we're restoring to (previousState) + const isAddition = actionType.endsWith('_add') + const isDeletion = actionType.endsWith('_delete') + + return ( +
+
e.stopPropagation()} + > +
+

+ Revert {label} +

+

+ {entityDescription} +

+
+ +
+

+ {description} +

+ +
+ {!isAddition && ( +
+
+ Current State +
+ 
+                  {formatStatePreview(newState)}
+
+
+ )} + {!isDeletion && ( +
+
+ {isAddition ? 'Will be removed' : 'Restored State'} +
+ 
+                  {isAddition ? formatStatePreview(newState) : formatStatePreview(previousState)}
+
+
+ )} + {isDeletion && ( +
+
+ Will be restored +
+ 
+                  {formatStatePreview(previousState)}
+
+
+ )} +
+
+ +
+ + +
+
+
+ ) +} diff --git a/src/components/editor/Toolbar.tsx b/src/components/editor/Toolbar.tsx index 213db07..56b9f9f 100644 --- a/src/components/editor/Toolbar.tsx +++ b/src/components/editor/Toolbar.tsx @@ -15,6 +15,7 @@ type ToolbarProps = { onImport: () => void onProjectSettings: () => void onShare: () => void + onHistory: () => void connectionState?: ConnectionState presenceUsers?: PresenceUser[] } @@ -44,6 +45,7 @@ export default function Toolbar({ onImport, onProjectSettings, onShare, + onHistory, connectionState, presenceUsers, }: ToolbarProps) { @@ -108,6 +110,12 @@ export default function Toolbar({ > Share +