chore: import upstream snapshot with attribution

apps/sim/stores/table/store.ts

@@ -0,0 +1,194 @@
+/**
+ * Zustand store for table undo/redo stacks.
+ * Ephemeral — no persistence. Stacks are keyed by tableId.
+ */
+
+import { generateShortId } from '@sim/utils/id'
+import { create } from 'zustand'
+import { devtools } from 'zustand/middleware'
+import type { TableUndoAction, TableUndoStacks, TableUndoState, UndoEntry } from './types'
+
+const STACK_CAPACITY = 100
+const EMPTY_STACKS: TableUndoStacks = { undo: [], redo: [] }
+
+let undoRedoInProgress = false
+
+function patchRowIdInEntry(entry: UndoEntry, oldRowId: string, newRowId: string): UndoEntry {
+  const { action } = entry
+  switch (action.type) {
+    case 'update-cell':
+      if (action.rowId === oldRowId) {
+        return { ...entry, action: { ...action, rowId: newRowId } }
+      }
+      break
+    case 'clear-cells': {
+      const hasMatch = action.cells.some((c) => c.rowId === oldRowId)
+      if (hasMatch) {
+        const patched = action.cells.map((c) =>
+          c.rowId === oldRowId ? { ...c, rowId: newRowId } : c
+        )
+        return { ...entry, action: { ...action, cells: patched } }
+      }
+      break
+    }
+    case 'update-cells': {
+      const hasMatch = action.cells.some((c) => c.rowId === oldRowId)
+      if (hasMatch) {
+        const patched = action.cells.map((c) =>
+          c.rowId === oldRowId ? { ...c, rowId: newRowId } : c
+        )
+        return { ...entry, action: { ...action, cells: patched } }
+      }
+      break
+    }
+    case 'create-row':
+      if (action.rowId === oldRowId) {
+        return { ...entry, action: { ...action, rowId: newRowId } }
+      }
+      break
+    case 'create-rows': {
+      const hasMatch = action.rows.some((r) => r.rowId === oldRowId)
+      if (hasMatch) {
+        const patched = action.rows.map((r) =>
+          r.rowId === oldRowId ? { ...r, rowId: newRowId } : r
+        )
+        return { ...entry, action: { ...action, rows: patched } }
+      }
+      break
+    }
+    case 'delete-rows': {
+      const hasMatch = action.rows.some((r) => r.rowId === oldRowId)
+      if (hasMatch) {
+        const patched = action.rows.map((r) =>
+          r.rowId === oldRowId ? { ...r, rowId: newRowId } : r
+        )
+        return { ...entry, action: { ...action, rows: patched } }
+      }
+      break
+    }
+    case 'delete-column': {
+      const hasMatch = action.cellData.some((c) => c.rowId === oldRowId)
+      if (hasMatch) {
+        const patched = action.cellData.map((c) =>
+          c.rowId === oldRowId ? { ...c, rowId: newRowId } : c
+        )
+        return { ...entry, action: { ...action, cellData: patched } }
+      }
+      break
+    }
+  }
+  return entry
+}
+
+/**
+ * Run a function without recording undo entries. Supports async functions —
+ * `undoRedoInProgress` stays true until the returned Promise settles, so
+ * mutations inside `executeAction` don't accidentally push new undo entries.
+ */
+export async function runWithoutRecording<T>(fn: () => T | Promise<T>): Promise<T> {
+  undoRedoInProgress = true
+  try {
+    return await fn()
+  } finally {
+    undoRedoInProgress = false
+  }
+}
+
+export const useTableUndoStore = create<TableUndoState>()(
+  devtools(
+    (set, get) => ({
+      stacks: {},
+
+      push: (tableId: string, action: TableUndoAction) => {
+        if (undoRedoInProgress) return
+
+        const entry: UndoEntry = { id: generateShortId(), action, timestamp: Date.now() }
+
+        set((state) => {
+          const current = state.stacks[tableId] ?? EMPTY_STACKS
+          const undoStack = [entry, ...current.undo].slice(0, STACK_CAPACITY)
+          return {
+            stacks: {
+              ...state.stacks,
+              [tableId]: { undo: undoStack, redo: [] },
+            },
+          }
+        })
+      },
+
+      popUndo: (tableId: string) => {
+        const current = get().stacks[tableId] ?? EMPTY_STACKS
+        if (current.undo.length === 0) return null
+
+        const [entry, ...rest] = current.undo
+        set((state) => ({
+          stacks: {
+            ...state.stacks,
+            [tableId]: {
+              undo: rest,
+              redo: [entry, ...current.redo],
+            },
+          },
+        }))
+        return entry
+      },
+
+      popRedo: (tableId: string) => {
+        const current = get().stacks[tableId] ?? EMPTY_STACKS
+        if (current.redo.length === 0) return null
+
+        const [entry, ...rest] = current.redo
+        set((state) => ({
+          stacks: {
+            ...state.stacks,
+            [tableId]: {
+              undo: [entry, ...current.undo],
+              redo: rest,
+            },
+          },
+        }))
+        return entry
+      },
+
+      patchRedoRowId: (tableId: string, oldRowId: string, newRowId: string) => {
+        set((state) => {
+          const stacks = state.stacks[tableId]
+          if (!stacks) return state
+          const patchedRedo = stacks.redo.map((entry) =>
+            patchRowIdInEntry(entry, oldRowId, newRowId)
+          )
+          return {
+            stacks: {
+              ...state.stacks,
+              [tableId]: { ...stacks, redo: patchedRedo },
+            },
+          }
+        })
+      },
+
+      patchUndoRowId: (tableId: string, oldRowId: string, newRowId: string) => {
+        set((state) => {
+          const stacks = state.stacks[tableId]
+          if (!stacks) return state
+          const patchedUndo = stacks.undo.map((entry) =>
+            patchRowIdInEntry(entry, oldRowId, newRowId)
+          )
+          return {
+            stacks: {
+              ...state.stacks,
+              [tableId]: { ...stacks, undo: patchedUndo },
+            },
+          }
+        })
+      },
+
+      clear: (tableId: string) => {
+        set((state) => {
+          const { [tableId]: _, ...rest } = state.stacks
+          return { stacks: rest }
+        })
+      },
+    }),
+    { name: 'table-undo-store' }
+  )
+)