objectToMatrix.js

/**
 * Converts an array of objects into a matrix format.
 * @param {Array} arr - Array of objects or arrays to convert
 * @returns {Array} Matrix where first row contains column headers and subsequent rows contain values
 */
function objectToMatrix(arr) {
  if (!arr || arr.length === 0) {
    return [[]];
  }

  // Step 1: Collect all possible column paths from all objects
  const allPaths = new Set();
  
  for (const item of arr) {
    const paths = getAllPaths(item);
    paths.forEach(path => allPaths.add(path));
  }

  // Step 2: Sort column names lexicographically
  const sortedColumns = Array.from(allPaths).sort();

  // Step 3: Create the matrix
  const matrix = [];
  
  // First row: column headers
  matrix.push(sortedColumns);

  // Subsequent rows: values for each object
  for (const item of arr) {
    const flattenedObj = flattenObject(item);
    const row = sortedColumns.map(column => 
      flattenedObj.hasOwnProperty(column) ? flattenedObj[column] : ""
    );
    matrix.push(row);
  }

  return matrix;
}

/**
 * Gets all possible paths in an object or array
 * @param {*} obj - Object or array to traverse
 * @param {string} prefix - Current path prefix
 * @returns {Array} Array of all paths
 */
function getAllPaths(obj, prefix = "") {
  const paths = [];

  if (obj === null || typeof obj !== "object") {
    // Primitive value - add the current path if it exists
    if (prefix) {
      paths.push(prefix);
    }
    return paths;
  }

  if (Array.isArray(obj)) {
    // Handle arrays
    for (let i = 0; i < obj.length; i++) {
      const currentPath = prefix ? `${prefix}.${i}` : `${i}`;
      const subPaths = getAllPaths(obj[i], currentPath);
      paths.push(...subPaths);
    }
  } else {
    // Handle objects
    const keys = Object.keys(obj);
    
    if (keys.length === 0) {
      // Empty object - no paths to add
      return paths;
    }

    for (const key of keys) {
      const currentPath = prefix ? `${prefix}.${key}` : key;
      const subPaths = getAllPaths(obj[key], currentPath);
      
      if (subPaths.length === 0) {
        // This is a leaf node (primitive value)
        paths.push(currentPath);
      } else {
        paths.push(...subPaths);
      }
    }
  }

  return paths;
}

/**
 * Flattens an object or array into dot-notation key-value pairs
 * @param {*} obj - Object or array to flatten
 * @param {string} prefix - Current path prefix
 * @returns {Object} Flattened object with dot-notation keys
 */
function flattenObject(obj, prefix = "") {
  const flattened = {};

  if (obj === null || typeof obj !== "object") {
    // Primitive value
    if (prefix) {
      flattened[prefix] = obj;
    }
    return flattened;
  }

  if (Array.isArray(obj)) {
    // Handle arrays
    for (let i = 0; i < obj.length; i++) {
      const currentPath = prefix ? `${prefix}.${i}` : `${i}`;
      const subFlattened = flattenObject(obj[i], currentPath);
      Object.assign(flattened, subFlattened);
    }
  } else {
    // Handle objects
    const keys = Object.keys(obj);
    
    for (const key of keys) {
      const currentPath = prefix ? `${prefix}.${key}` : key;
      const subFlattened = flattenObject(obj[key], currentPath);
      
      if (Object.keys(subFlattened).length === 0) {
        // This is a leaf node (primitive value)
        flattened[currentPath] = obj[key];
      } else {
        Object.assign(flattened, subFlattened);
      }
    }
  }

  return flattened;
}

module.exports = { objectToMatrix };