It has been noted that @aqm's answer may produce an incorrect result when the index exceeds 702.

Upon counting from A to Z and AA to ZZ, it is evident that the total count reaches 702 (26 + 26 * 26 = 702). Hence, for toExcelHeader(703), the expected output should be 'AAA', but unfortunately, the function currently returns 'ABA'.

Fortunately, a revised version is provided below:

(Unfortunately, I do not have enough reputation to respond within the original thread)

function toExcelHeader(num) {

  if(num <= 0) {
    return '';
  }

  var str = num.toString(26);
  var arr = str.split('').map(char => {
    var code = char.charCodeAt(0);
    if(code >= 48 && code <= 57) {
      code += 16; // convert 1-9 to A-I and 0 to @
    } else {
      code -= 23; // convert a-p to J-Z
    }
    return code;
  });

  // convert 'A@' to 'Z', 'B@' to 'AZ', etc. 
  // ascii code of '@' is 64
  var index = arr.indexOf(64)
  while(index >= 0) {
    if(index == 0) {
      arr.shift();  // remove head '@'
    } else {
      arr[index] += 26;
      arr[index - 1]--;
    }
    index = arr.indexOf(64);
  }

  var chars = arr.map(code => String.fromCharCode(code));
  return chars.join('');
}

// toExcelHeader(0) == ""
// toExcelHeader(1) == "A"
// toExcelHeader(26) == "Z"
// toExcelHeader(27) == "AA"
// toExcelHeader(702) == "ZZ"
// toExcelHeader(703) == "AAA"
// toExcelHeader(18278) == "ZZZ"
// toExcelHeader(18279) == "AAAA"

Discovered this simple function in a package I found at this link

 const letters =
      ['A', 'B', 'C', 'D', 'E',
        'F', 'G', 'H', 'I', 'J',
        'K', 'L', 'M', 'N', 'O',
        'P', 'Q', 'R', 'S', 'T',
        'U', 'V', 'W', 'X', 'Y', 'Z'];

    const convertToExcelHeader = (index) => {
      index -= 1;

      const quotient = Math.floor(index / 26);
      if (quotient > 0) {
        return convertToExcelHeader(quotient) + letters[index % 26];
      }

      return letters[index % 26];
    };

convertToExcelHeader(0) === undefined            
convertToExcelHeader(1) === "A"           
convertToExcelHeader(26) === "Z"          
convertToExcelHeader(27) === "AA"         
convertToExcelHeader(702) === "ZZ"        
convertToExcelHeader(703) === "AAA" 
convertToExcelHeader(2074) === "CAT"
convertToExcelHeader(3101) === "DOG"      
convertToExcelHeader(18278) === "ZZZ"     
convertToExcelHeader(18279) === "AAAA"

function generateColumnNames(number) {
  let output = [];

  const startCharCode = "A".charCodeAt(0);
  const endCharCode = "Z".charCodeAt(0);

  let alphabetSize = endCharCode - startCharCode + 1;
  const repeatCount = Math.floor(number / alphabetSize);

  let currentIndex = 0;
  let initialString = "";
  let charValue = "";

  while (currentIndex <= repeatCount) {
    if (currentIndex > 0) {
      initialString = String.fromCharCode(startCharCode + currentIndex - 1);
    }

    if (currentIndex === repeatCount) {
        alphabetSize = number % alphabetSize;
      }

    for (var i = 0; i < alphabetSize; i++) {
      charValue = String.fromCharCode(startCharCode + i);

      output.push(initialString + charValue);
    }
    currentIndex++;
  }

  console.log(output, output.length);
  return output;
}

generateColumnNames(55);

Although this thread may be old, I couldn't find any tips when searching for some guidance. So, I decided to come up with my own solution and share it here in case it can benefit others. This code creates headers like: A, B.. Z, AA-AZ, AB-AZ, ... ZZ-ZZ, allowing a maximum of 702 headers. If you need more, you can customize the function accordingly.

The function takes a number representing the amount of Excel-like headers to generate and requires an array of ALPHABETICAL_ORDERED_LETTERS ('abcdefghijklmnopqrstuvwxyz'.toUpperCase().split('')).

For example: buildExcelLikeHeaders(59)

const MAX_LENGTH = 702;
// capable of handling up to 702 columns;

function buildArray(remainingRows, prevArrOfHeaders = [], size, letter = 'A', index = 0) {
  const newSetOfHeaders = [];
  let currentIndex = index;

  if (currentIndex > MAX_LENGTH) currentIndex = MAX_LENGTH;

  for (let i = 0; i < remainingRows; i++) {
    if (ALPHABETICAL_ORDERED_LETTERS[i]) {
      const header = `${letter + ALPHABETICAL_ORDERED_LETTERS[i]}-${letter}Z`;
      newSetOfHeaders.push(header);
    }
  }

  const nextArrayOfHeaders = [...prevArrOfHeaders, ...newSetOfHeaders];

  const remainingRowsNext = Math.abs(remainingRows - ALPHABETICAL_ORDERED_LETTERS.length);
  
  if (nextArrayOfHeaders.length < size && nextArrayOfHeaders.length < MAX_LENGTH) {
    currentIndex++;

    return buildArray(
      remainingRowsNext,
      nextArrayOfHeaders,
      size,
      ALPHABETICAL_ORDERED_LETTERS[currentIndex].toUpperCase(),
      currentIndex,
    );
  }

  return nextArrayOfHeaders;
}

const buildExcelLikeHeaders = row => {
  if (row <= ALPHABETICAL_ORDERED_LETTERS.length) {
    return ALPHABETICAL_ORDERED_LETTERS.slice(0, row);
  }

  const remainingRows = row - ALPHABETICAL_ORDERED_LETTERS.length;
  const referenceSize = row;

  return buildArray(remainingRows, ALPHABETICAL_ORDERED_LETTERS, referenceSize);
};