Skip to content

Beautiful Open-Source Form Builder

15.6 KB
Raw Blame
import { computed } from 'vue'
import { useTableColumnPreferences } from './useTableColumnPreferences'
import debounce from 'debounce'
import {
  ATTRIBUTION_PARAMETERS,
  attributionColumnAccessor,
  attributionColumnId,
} from '~/lib/forms/submissionAttribution'

const normalizeColumnList = (columns) => {
  if (Array.isArray(columns)) {
    return columns
  }

  if (columns && typeof columns === 'object') {
    return Object.values(columns)
  }

  return []
}

// Provides a composable for managing the state of a table component, including column visibility, pinning, sizing, and wrapping.
// It synchronizes table state with user preferences (such as column order and visibility) and supports dynamic updates based on form structure and workspace context.

export function useTableState(form, withActions = false) {
  // Internal preferences helper (hidden from consumers)
  const columnPreferences = useTableColumnPreferences(
    computed(() => form.value?.id || form.value?.slug)
  )

  const { getColumnPreference, setColumnPreference } = columnPreferences
  const { hasFeature } = usePlanFeatures()

  /* -------------------------------------------------------------------------- */
  /*                               Column config                               */
  /* -------------------------------------------------------------------------- */

  // Computed column configurations (base definition for every column)
  const columnConfigurations = computed(() => {
    try {
      const properties = normalizeColumnList(form.value?.properties)
      const removedProperties = normalizeColumnList(form.value?.removed_properties)
      if (properties.length === 0) return []

      const baseColumns = properties
        .filter((field) => {
          return field.type && typeof field.type === 'string' && !field.type.startsWith('nf-')
        })
        .map(col => {
          const { columns: matrixColumns, ...rest } = col
          return {
            ...rest,
            ...(col.type === 'matrix' && { matrix_columns: matrixColumns }),
            id: col.id,
            accessorKey: col.id,
            header: col.name,
            isRemoved: false,
            enableResizing: true,
            minSize: 100,
            maxSize: 500,
          }
        })

       // Add removed properties
       if (removedProperties.length > 0) {
         removedProperties.forEach(property => {
           const { columns: matrixColumns, ...rest } = property
           baseColumns.push({
             ...(property.type === 'matrix' ? { ...rest, matrix_columns: matrixColumns } : { ...rest }),
             id: property.id,
             accessorKey: property.id,
             header: property.name,
             isRemoved: true,
             enableResizing: true,
             minSize: 100,
             maxSize: 500,
           })
         })
       }

       // Add created_at column if not present
       if (!baseColumns.find(property => property.id === 'created_at')) {
         baseColumns.push({
           id: 'created_at',
           accessorKey: 'created_at',
           header: 'Created at',
           type: 'date',
           enableResizing: true,
           minSize: 100,
           maxSize: 500,
         })
       }

       ATTRIBUTION_PARAMETERS.forEach((parameter) => {
         const columnId = attributionColumnId(parameter)
         baseColumns.push({
           id: columnId,
           accessorFn: attributionColumnAccessor(parameter),
           header: parameter,
           type: 'text',
           hiddenByDefault: true,
           enableResizing: true,
           minSize: 100,
           maxSize: 500,
         })
       })

       if (hasFeature('enable_partial_submissions') && (form.value?.enable_partial_submissions ?? false)) {
         if (!baseColumns.find(property => property.id === 'status')) {
           baseColumns.push({
            id: 'status',
            accessorKey: 'status',
            header: 'Status',
            type: 'status',
            enableColumnFilter: true,
            filterFn: 'equals',
            enableResizing: true,
            minSize: 100,
            maxSize: 500,
           })
         }
       }

       if (hasFeature('enable_ip_tracking') && (form.value?.enable_ip_tracking ?? false)) {
         if (!baseColumns.find(property => property.id === 'ip_address')) {
           baseColumns.push({
            id: 'ip_address',
            accessorKey: 'ip_address',
            header: 'IP Address',
            type: 'ip_address',
            enableResizing: true,
            minSize: 100,
            maxSize: 500,
           })
         }
       }

       return baseColumns
    } catch (error) {
      console.error('Error in columnConfigurations computed:', error)
      return []
    }
  })

  /* -------------------------------------------------------------------------- */
  /*                       Writable computed bridges (reactive)                 */
  /* -------------------------------------------------------------------------- */

  // Column visibility
  const columnVisibility = computed({
    get() {
      // Establish dependency on the entire preferences object
      const prefs = columnPreferences.preferences.value
      const visibility = {}
      const configCols = columnConfigurations.value || []
      configCols.forEach(col => {
        const pref = prefs.columns[col.id] || {}
        // Use preference if set, otherwise hide removed and system-hidden columns.
        const visible = pref.visible !== null && pref.visible !== undefined
          ? pref.visible
          : !col.isRemoved && !col.hiddenByDefault
        visibility[col.id] = visible
      })
      return visibility
    },
    set(newVisibility) {
      Object.entries(newVisibility).forEach(([columnId, visible]) => {
        const pref = getColumnPreference(columnId)
        const column = columnConfigurations.value.find(candidate => candidate.id === columnId)
        const currentVisible = pref.visible !== null && pref.visible !== undefined 
          ? pref.visible 
          : !column?.isRemoved && !column?.hiddenByDefault
        if (currentVisible !== visible) {
          setColumnPreference(columnId, { visible })
        }
      })
    }
  })

  // Column pinning
  const columnPinning = computed({
    get() {
      const prefs = columnPreferences.preferences.value
      const pinning = { left: ['select'], right: ['actions'] }
      const configCols = columnConfigurations.value || []
      configCols.forEach(col => {
        const pref = prefs.columns[col.id] || {}
        // Only allow left pinning for regular columns
        if (pref.pinned === 'left') pinning.left.push(col.id)
        // Actions column is always pinned right, other columns cannot be pinned right
      })
      return pinning
    },
    set(newPinning) {
      const { left = ['select'] } = newPinning || {}
      const configCols = columnConfigurations.value || []

      // First, clear pinning for all applicable columns (except actions)
      configCols.forEach(col => {
        if (['actions', 'select'].includes(col.id)) return
        setColumnPreference(col.id, { pinned: false })
      })

      // Apply new left pinning only
      left.forEach(id => {
        if (['actions','select'].includes(id)) return
        setColumnPreference(id, { pinned: 'left' })
      })
      // Note: actions column pinning is handled automatically in the getter
    }
  })

  // Column sizing (table column resize)
  const columnSizing = computed({
    get() {
      const savedSizing = columnPreferences.preferences.value.globalSizing
      if (savedSizing && typeof savedSizing === 'object' && Object.keys(savedSizing).length > 0) {
        // Ensure all columns have a size, fallback to 200 if missing
        const sizing = {}
        for (const col of tableColumns.value) {
          sizing[col.id] = savedSizing[col.id] ?? 200
        }
        return sizing
      }

      // No saved sizing, use default 200 for all columns
      const defaultSizing = {}
      for (const col of tableColumns.value) {
        if (col.id === 'actions') {
          defaultSizing[col.id] = 80
        } else {
          defaultSizing[col.id] = 200
        }
      }
      return defaultSizing
    },
    set(newSizing) {
      columnPreferences.setColumnSizing(newSizing)
    }
  })

  // Debounced resize handler to avoid excessive localStorage writes
  const debouncedSetColumnSizing = debounce((newSizing) => {
    columnPreferences.setColumnSizing(newSizing)
  }, 50) // 150ms debounce

  // Handle individual column resize - simple preference saving
  const handleColumnResize = (columnId, size) => {
    size = Math.min(Math.max(size, 80), 700)
    const currentSizing = columnSizing.value || {}
    const newSizing = {
      ...currentSizing,
      [columnId]: size
    }
    
    // Update the reactive state immediately for smooth UX
    columnSizing.value = newSizing
    
    // Save to preferences with debounce
    debouncedSetColumnSizing(newSizing)
  }



  // Column wrapping (read-only)
  const columnWrapping = computed(() => {
    const prefs = columnPreferences.preferences.value
    const wrapping = {}
    const configCols = columnConfigurations.value || []
    configCols.forEach(col => {
      const pref = prefs.columns[col.id] || {}
      wrapping[col.id] = pref.wrapped ?? false
    })
    return wrapping
  })

  /* -------------------------------------------------------------------------- */
  /*                              Column ordering                               */
  /* -------------------------------------------------------------------------- */

  // Column order for TanStack Table (array of column IDs)
  const columnOrder = computed({
    get() {
      try {
        // Return all column IDs in the correct order
        const cols = tableColumns.value || []
        return cols.map(col => col.id)
      } catch (error) {
        console.error('Error in columnOrder computed:', error)
        return []
      }
    },
    set(newOrder) {
      try {
        // newOrder is an array of column IDs
        // Filter out 'select' and 'actions' columns as they're managed separately
        const dataColumnIds = newOrder.filter(id => !['select', 'actions'].includes(id))
        
        // Update preferences for each column based on the new order
        dataColumnIds.forEach((id, index) => {
          columnPreferences.setColumnPreference(id, { order: index })
        })
        
        // Give high order numbers to columns not in the new order
        const allColumnIds = columnConfigurations.value.map(c => c.id)
        allColumnIds.forEach(id => {
          if (!dataColumnIds.includes(id)) {
            columnPreferences.setColumnPreference(id, { order: 9999 })
          }
        })
      } catch (error) {
        console.error('Error in columnOrder setter:', error)
      }
    }
  })

  // Helper function to set a specific column to a specific index (used by drag-and-drop)
  const setColumnOrder = (columnId, newIndex) => {
    try {
      // Get current column order
      const currentOrder = columnOrder.value
      
      // Find the column in the current order
      const currentIndex = currentOrder.indexOf(columnId)
      if (currentIndex === -1) return
      
      // Create new order by moving the column
      const newOrder = [...currentOrder]
      newOrder.splice(currentIndex, 1)
      newOrder.splice(newIndex, 0, columnId)
      
      // Update via columnOrder setter (triggers TanStack Table update)
      columnOrder.value = newOrder
    } catch (error) {
      console.error('Error in setColumnOrder:', error)
    }
  }

  // Ordered columns for display (read-only getter)
  const orderedColumns = computed(() => {
    try {
      const prefs = columnPreferences.preferences.value
      const configCols = columnConfigurations.value || []
      const columns = Array.isArray(configCols) ? [...configCols] : []

      // Sort by order preference, then by original position
      columns.sort((a, b) => {
        const prefA = prefs.columns[a.id] || {}
        const prefB = prefs.columns[b.id] || {}

        const orderA = prefA.order ?? 9999
        const orderB = prefB.order ?? 9999

        if (orderA !== orderB) {
          return orderA - orderB
        }

        // Fallback to original order
        return configCols.indexOf(a) - configCols.indexOf(b)
      })

      return columns
    } catch (error) {
      console.error('Error in orderedColumns computed:', error)
      return []
    }
  })

  // Final array of columns to be passed to the table component
  const tableColumns = computed(() => {
    try {
      // Ensure we have a valid array to work with  
      const cols = orderedColumns.value && Array.isArray(orderedColumns.value) ? [...orderedColumns.value] : []

      // Add actions columns
      if (import.meta.client && withActions) {
        cols.unshift({
          id: 'select',
          accessorKey: 'select',
          header: '',
          enableResizing: false,
          size: 40,
          meta: {
            class: {
              th: 'bg-transparent',
              td: 'backdrop-blur-xs bg-white/70'
            }
          }
        })

        cols.push({
          id: 'actions',
          accessorKey: 'actions',
          header: '',
          enableResizing: false,
          size: 80,
          meta: {
            class: {
              th: 'bg-transparent',
              td: 'backdrop-blur-xs bg-white/70'
            }
          }
        })
      }

      return cols ?? []
    } catch (error) {
      console.error('Error in tableColumns computed:', error)
      return []
    }
  })

  /* -------------------------------------------------------------------------- */
  /*                              Helper functions                              */
  /* -------------------------------------------------------------------------- */

  // Toggle column visibility
  const toggleColumnVisibility = (columnId) => {
    const currentVisibility = columnVisibility.value[columnId]
    columnVisibility.value = {
      ...columnVisibility.value,
      [columnId]: !currentVisibility
    }
  }

  // Toggle column wrapping
  const toggleColumnWrapping = (columnId) => {
    setColumnPreference(columnId, { wrapped: !(columnWrapping.value[columnId] || false) })
  }

  // Toggle column pinning
  const toggleColumnPin = (columnId) => {
    const pref = getColumnPreference(columnId) || {}
    
    if (pref.pinned === 'left') {
      // If currently pinned, just unpin it
      setColumnPreference(columnId, { pinned: false })
    } else {
      // If not currently pinned, first unpin all other columns, then pin this one
      const configCols = columnConfigurations.value || []
      
      // Clear all existing pins
      configCols.forEach(col => {
        if (['actions', 'select'].includes(col.id) && col.id !== columnId) {
          setColumnPreference(col.id, { pinned: false })
        }
      })
      
      // Pin the target column and make it visible
      setColumnPreference(columnId, { pinned: 'left', visible: true })
    }
  }

  /* -------------------------------------------------------------------------- */
  /*                              Public API                                   */
  /* -------------------------------------------------------------------------- */

  return {
    // Columns
    tableColumns,
    orderedColumns,
    setColumnOrder,

    // Preferences (writable computeds)
    columnVisibility,
    columnPinning,
    columnWrapping,
    columnSizing,
    columnOrder, // TanStack Table column order state
    
    // Preference helpers (for components)
    getColumnPreference,
    setColumnPreference,
    resetPreferences: columnPreferences.resetPreferences,
    resetColumn: columnPreferences.resetColumn,
    toggleColumnVisibility: toggleColumnVisibility,
    toggleColumnWrapping,
    toggleColumnPin: toggleColumnPin,
    handleColumnResize,
  }
}