Turn each range into each individual hour within the range, then:

• if the hour already exists in the array, return false
• else, push to the array

const getResult = (ranges) => {
  const filled = [];
  for (const range of ranges) {
    let [start, end] = range.split('-').map(Number);
    while (end !== start) { // Exclusive
      if (filled.includes(start)) return false;
      filled.push(start);
      start++;
    }
  }
  return true;
};
console.log(getResult(["09-13", "12-14"]));
console.log(getResult(["07-09", "10-12", "15-19"]));

Your current approach doesn't look to have any notion of turning the ranges into their individual hours, or of identifying overlaps.

• Sort the time slots based on their start time.
• Loop over all the time slots in the sorted array and if anytime the start of a slot is less than the end of the previous one, then return false.
• If the whole loop is exhausted return true.

function isValid(time) {
  const sortedTime = [...time].sort((a, b) => {
    const slotA = Number(a.split("-")[0]);
    const slotB = Number(b.split("-")[0]);
    return slotA - slotB;
  });

  let last;
  for (let t of sortedTime) {
    const [start, end] = t.split("-").map(Number);
    if (last && start < last) {
      return false;
    }
    last = end;
  }
  return true;
}

console.log(isValid(["12-14", "09-13"]));
console.log(isValid(["10-12", "07-09", "15-19"]));

Your format is already useful for direct >= comparisons, once we split the values on their -'s. So we can simply sort the values, then check that in every case after the first one, that the start portion (before the -) is at least as large as the end portion (after the -) of the previous value. It could look like this:

const feasible = (times) => [... times] 
  .sort () 
  .every ((t, i, a) => i == 0 || t .split ('-') [0] >= a [i - 1] .split ('-') [1])  


console .log (feasible (["09-13", "12-14"]))
console .log (feasible (["07-09", "10-12", "15-19"]))

We use the i == 0 || to simply avoid testing the first of the sorted values.

This involves splitting each of the values twice (well, except the first one.) If this inefficiency bothers you, we could solve it (using more memory; there's always a tradeoff!) by splitting them and saving the result:

const feasible = (times) => [... times] 
  .sort () 
  .map (s => s .split ('-')) 
  .every ((t, i, a) => i == 0 || t [0] >= a [i - 1]  [1])