robobyte-front-builder 1.0.17 → 1.0.21

package/src/views/genericTable/updateRefHelpers.js

@@ -0,0 +1,424 @@
+/**
+ * Helper functions for managing updateRef in AG Grid
+ *
+ * updateRef structure: Array of row updates with original and updated data
+ * [
+ *   {
+ *     rowId: "123",
+ *     originalData: {
+ *       Id: 123,
+ *       IsPublic: false,  // original value
+ *       Name: "Original Name",
+ *       Product: { Name: "Original Product Name" }
+ *     },
+ *     data: {
+ *       Id: 123,
+ *       IsPublic: true,  // updated field
+ *       Name: "Original Name",
+ *       Product: { Name: "Updated Name" }  // updated nested field
+ *     }
+ *   },
+ *   {
+ *     rowId: "456",
+ *     originalData: {
+ *       Id: 456,
+ *       Status: "Inactive",
+ *       Name: "Original"
+ *     },
+ *     data: {
+ *       Id: 456,
+ *       Status: "Active",  // updated field
+ *       Name: "Original"
+ *     }
+ *   }
+ * ]
+ */
+
+/**
+ * Get nested value from object using dot notation path
+ * @param {object} obj - The object to traverse
+ * @param {string} path - Dot-separated path (e.g., "Product.Name")
+ * @returns {any} The value at the path, or undefined if not found
+ */
+export const getNestedValue = (obj, path) => {
+  if (!obj || !path) return undefined
+
+  const keys = path.split('.')
+  let current = obj
+
+  for (const key of keys) {
+    if (current == null) return undefined
+    current = current[key]
+  }
+
+  return current
+}
+
+/**
+ * Set nested value in object using dot notation path
+ * @param {object} obj - The object to modify
+ * @param {string} path - Dot-separated path (e.g., "Product.Name")
+ * @param {any} value - The value to set
+ */
+export const setNestedValue = (obj, path, value) => {
+  if (!obj || !path) return
+
+  const keys = path.split('.')
+  const lastKey = keys.pop()
+  let current = obj
+
+  // Navigate to the parent object
+  for (const key of keys) {
+    if (!(key in current)) {
+      current[key] = {}
+    }
+    current = current[key]
+  }
+
+  // Set the value
+  current[lastKey] = value
+}
+
+/**
+ * Normalize rowId to string for comparison (handles both number and string)
+ * @param {string|number} rowId - The row ID to normalize
+ * @returns {string} Normalized row ID as string
+ */
+const normalizeRowId = (rowId) => {
+  return rowId != null ? String(rowId) : null
+}
+
+/**
+ * Compare two rowIds (handles both number and string)
+ * @param {string|number} rowId1 - First row ID
+ * @param {string|number} rowId2 - Second row ID
+ * @returns {boolean} True if they match
+ */
+const compareRowIds = (rowId1, rowId2) => {
+  return normalizeRowId(rowId1) === normalizeRowId(rowId2)
+}
+
+/**
+ * Get the unique row ID from row data based on rowUniqueId configuration
+ * @param {object} rowData - The AG Grid row data
+ * @param {array} rowUniqueId - Array of field paths that uniquely identify a row (from settings)
+ * @returns {string} Composite key string
+ */
+export const getRowId = (rowData, rowUniqueId) => {
+  if (!rowData || !rowUniqueId) return null
+
+  // Accept both a plain string ('Id') and an array (['Id', 'SubId'])
+  const ids = Array.isArray(rowUniqueId) ? rowUniqueId : [rowUniqueId]
+
+  if (ids.length === 0) return null
+
+  // If single field, return its value directly as string
+  if (ids.length === 1) {
+    const value = getNestedValue(rowData, ids[0])
+    return value != null ? String(value) : null
+  }
+
+  // If multiple fields, create composite key
+  const keyParts = ids.map(fieldPath => {
+    const value = getNestedValue(rowData, fieldPath)
+    return value != null ? String(value) : ''
+  })
+
+  return keyParts.join('|')
+}
+
+/**
+ * Update a field value in updateRef
+ * @param {React.MutableRefObject} updateRef - The ref object storing updates (array)
+ * @param {object} rowData - The AG Grid row data
+ * @param {array} rowUniqueId - Array of field paths for row identification
+ * @param {string} fieldPath - The field to update (supports dot notation)
+ * @param {any} newValue - The new value
+ */
+export const setUpdateRefValue = (updateRef, rowData, rowUniqueId, fieldPath, newValue) => {
+  if (!updateRef || !updateRef.current) {
+//    console.warn('updateRef is not initialized')
+    return
+  }
+
+  const rowId = getRowId(rowData, rowUniqueId)
+  if (!rowId) {
+  //  console.warn('Could not determine row ID from rowData', rowData, rowUniqueId)
+    return
+  }
+
+  // Ensure updateRef.current is an array
+  if (!Array.isArray(updateRef.current)) {
+    updateRef.current = []
+  }
+
+  // Find existing row update (use comparison to handle both string and number)
+  let rowUpdate = updateRef.current.find(item => compareRowIds(item.rowId, rowId))
+
+  if (!rowUpdate) {
+    // First edit: Create new row update entry with both originalData and data (deep clones)
+    rowUpdate = {
+      rowId: normalizeRowId(rowId),
+      originalData: JSON.parse(JSON.stringify(rowData)),
+      data: JSON.parse(JSON.stringify(rowData))
+    }
+    updateRef.current.push(rowUpdate)
+  } else {
+    // Row exists - merge with new rowData (...old, ...new)
+    // New fields are added, existing fields are updated, fields only in old are preserved
+    const clonedRowData = JSON.parse(JSON.stringify(rowData))
+    rowUpdate.data = {
+      ...rowUpdate.data,
+      ...clonedRowData
+    }
+  }
+
+  // Set the field value in the data object (supports nested paths)
+  setNestedValue(rowUpdate.data, fieldPath, newValue)
+
+ // console.log('updateRef updated:', rowId, fieldPath, newValue)
+}
+
+/**
+ * Update multiple fields in a row at once
+ * @param {React.MutableRefObject} updateRef - The ref object storing updates (array)
+ * @param {object} rowData - The AG Grid row data
+ * @param {array} rowUniqueId - Array of field paths for row identification
+ * @param {object} updates - Object with fieldPath: newValue pairs
+ */
+export const setUpdateRefRow = (updateRef, rowData, rowUniqueId, updates) => {
+  if (!updateRef || !updateRef.current) {
+  //  console.warn('updateRef is not initialized')
+    return
+  }
+
+  const rowId = getRowId(rowData, rowUniqueId)
+  if (!rowId) {
+   // console.warn('Could not determine row ID from rowData', rowData, rowUniqueId)
+    return
+  }
+
+  // Ensure updateRef.current is an array
+  if (!Array.isArray(updateRef.current)) {
+    updateRef.current = []
+  }
+
+  // Find existing row update (use comparison to handle both string and number)
+  let rowUpdate = updateRef.current.find(item => compareRowIds(item.rowId, rowId))
+
+  if (!rowUpdate) {
+    // First edit: Create new row update entry with both originalData and data (deep clones)
+    rowUpdate = {
+      rowId: normalizeRowId(rowId),
+      originalData: JSON.parse(JSON.stringify(rowData)),
+      data: JSON.parse(JSON.stringify(rowData))
+    }
+    updateRef.current.push(rowUpdate)
+  } else {
+    // Row exists - merge with new rowData (...old, ...new)
+    // New fields are added, existing fields are updated, fields only in old are preserved
+    const clonedRowData = JSON.parse(JSON.stringify(rowData))
+    rowUpdate.data = {
+      ...rowUpdate.data,
+      ...clonedRowData
+    }
+  }
+
+  // Apply all updates to the data object (supports nested paths)
+  Object.entries(updates).forEach(([fieldPath, value]) => {
+    setNestedValue(rowUpdate.data, fieldPath, value)
+  })
+
+ // console.log('updateRef row updated:', rowId, updates)
+}
+
+/**
+ * Get a field value from updateRef or fallback to original row data
+ * @param {React.MutableRefObject} updateRef - The ref object storing updates (array)
+ * @param {object} rowData - The AG Grid row data
+ * @param {array} rowUniqueId - Array of field paths for row identification
+ * @param {string} updateRefPath - The field path to get from updateRef.data (supports dot notation)
+ * @param {string} rowDataPath - The field path to get from original rowData if not in updateRef (optional, defaults to updateRefPath)
+ * @returns {any} The updated value if exists, otherwise the original value from rowData
+ */
+export const getUpdateRefValue = (updateRef, rowData, rowUniqueId, updateRefPath, rowDataPath) => {
+  // Default rowDataPath to updateRefPath if not provided
+  const fallbackPath = rowDataPath !== undefined ? rowDataPath : updateRefPath
+
+  if (!updateRef || !updateRef.current || !Array.isArray(updateRef.current)) {
+    return getNestedValue(rowData, fallbackPath)
+  }
+
+  const rowId = getRowId(rowData, rowUniqueId)
+
+  if (!rowId) {
+    return getNestedValue(rowData, fallbackPath)
+  }
+
+  // Find row update (use comparison to handle both string and number)
+  const rowUpdate = updateRef.current.find(item => compareRowIds(item.rowId, rowId))
+
+  if (!rowUpdate || !rowUpdate.data) {
+    return getNestedValue(rowData, fallbackPath)
+  }
+
+  // Get value from the updated data object using updateRefPath
+  return getNestedValue(rowUpdate.data, updateRefPath)
+}
+
+/**
+ * Check if a row has been updated in updateRef
+ * @param {React.MutableRefObject} updateRef - The ref object storing updates (array)
+ * @param {object} rowData - The AG Grid row data
+ * @param {array} rowUniqueId - Array of field paths for row identification
+ * @returns {boolean} True if the row has been updated
+ */
+export const hasUpdateRefValue = (updateRef, rowData, rowUniqueId) => {
+  if (!updateRef || !updateRef.current || !Array.isArray(updateRef.current)) {
+    return false
+  }
+
+  const rowId = getRowId(rowData, rowUniqueId)
+  if (!rowId) {
+    return false
+  }
+
+  const rowUpdate = updateRef.current.find(item => compareRowIds(item.rowId, rowId))
+  return !!rowUpdate
+}
+
+/**
+ * Remove a specific row from updateRef by rowData and rowUniqueId
+ * @param {React.MutableRefObject} updateRef - The ref object storing updates (array)
+ * @param {object} rowData - The AG Grid row data
+ * @param {array} rowUniqueId - Array of field paths for row identification
+ */
+export const removeUpdateRefByRowId = (updateRef, rowData, rowUniqueId) => {
+  if (!updateRef || !updateRef.current || !Array.isArray(updateRef.current)) {
+    return
+  }
+
+  const rowId = getRowId(rowData, rowUniqueId)
+  if (!rowId) {
+    console.warn('Could not determine row ID from rowData', rowData, rowUniqueId)
+    return
+  }
+
+  const index = updateRef.current.findIndex(item => compareRowIds(item.rowId, rowId))
+  if (index !== -1) {
+    updateRef.current.splice(index, 1)
+    console.log('updateRef row removed:', rowId)
+  }
+}
+
+/**
+ * Clear all updates for a specific row
+ * @param {React.MutableRefObject} updateRef - The ref object storing updates (array)
+ * @param {object} rowData - The AG Grid row data
+ * @param {array} rowUniqueId - Array of field paths for row identification
+ */
+export const clearUpdateRefRow = (updateRef, rowData, rowUniqueId) => {
+  if (!updateRef || !updateRef.current || !Array.isArray(updateRef.current)) {
+    return
+  }
+
+  const rowId = getRowId(rowData, rowUniqueId)
+  if (!rowId) {
+    return
+  }
+
+  removeUpdateRefByRowId(updateRef, rowId)
+}
+
+/**
+ * Normalize updateRef by merging duplicate entries (handles mixed number/string rowIds)
+ * @param {React.MutableRefObject} updateRef - The ref object storing updates (array)
+ */
+export const normalizeUpdateRef = (updateRef) => {
+  if (!updateRef || !updateRef.current || !Array.isArray(updateRef.current)) {
+    return
+  }
+
+  const normalized = []
+  const seen = new Set()
+
+  updateRef.current.forEach(item => {
+    const normalizedId = normalizeRowId(item.rowId)
+
+    if (seen.has(normalizedId)) {
+      // Find existing entry and merge data
+      const existing = normalized.find(n => compareRowIds(n.rowId, normalizedId))
+      if (existing) {
+        // Merge data from duplicate entry (later values override)
+        Object.assign(existing.data, item.data)
+        // Keep originalData if not present
+        if (!existing.originalData && item.originalData) {
+          existing.originalData = item.originalData
+        }
+      }
+    } else {
+      // Add new normalized entry
+      normalized.push({
+        ...item,
+        rowId: normalizedId
+      })
+      seen.add(normalizedId)
+    }
+  })
+
+  updateRef.current = normalized
+  console.log('updateRef normalized, merged duplicates')
+}
+
+/**
+ * Clone updateRef to originalRefData (backup before changes)
+ * @param {React.MutableRefObject} updateRef - The ref object storing updates (array)
+ * @param {React.MutableRefObject} originalRefData - The ref to store the clone
+ */
+export const cloneUpdateRefToOriginal = (updateRef, originalRefData) => {
+  if (!updateRef || !updateRef.current || !originalRefData) {
+    return
+  }
+
+  originalRefData.current = JSON.parse(JSON.stringify(updateRef.current))
+  console.log('updateRef cloned to originalRefData:', originalRefData.current.length, 'rows')
+}
+
+/**
+ * Restore updateRef from originalRefData (reset to backup)
+ * @param {React.MutableRefObject} updateRef - The ref object storing updates (array)
+ * @param {React.MutableRefObject} originalRefData - The ref with the backup data
+ */
+export const restoreUpdateRefFromOriginal = (updateRef, originalRefData) => {
+  if (!updateRef || !originalRefData || !originalRefData.current) {
+    return
+  }
+
+  updateRef.current = JSON.parse(JSON.stringify(originalRefData.current))
+  console.log('updateRef restored from originalRefData:', updateRef.current.length, 'rows')
+}
+
+/**
+ * Clear all updates
+ * @param {React.MutableRefObject} updateRef - The ref object storing updates (array)
+ */
+export const clearAllUpdateRef = (updateRef) => {
+  if (!updateRef || !updateRef.current) {
+    return
+  }
+
+  updateRef.current = []
+}
+
+/**
+ * Get all updated rows
+ * @param {React.MutableRefObject} updateRef - The ref object storing updates (array)
+ * @returns {array} The current updateRef.current array
+ */
+export const getAllUpdates = (updateRef) => {
+  if (!updateRef || !updateRef.current) {
+    return []
+  }
+
+  return updateRef.current
+}