I think you don't want random numbers. It seems that you want a set of numbers based on some rules. Random means something else.

If I understand well your question you want to generate all possible numbers containing only a set of digits from a range of numbers. Is this an accurate description?

If so, this is similar with what you want: Generate random numbers only with specific digits

Edit:

You are right, so you want only one number. In javascript you could do something like this:

I edited the algorithm to take into account min and max in probably the most lazy way. I didn't take into account cases where numbers can't be generated, it will return undefined.

There are so many ways to do this. Your algorithm can work too and maybe more efficient but it seems to have an issue with 0, it will generate numbers with 0 even if it's not in the digits array.

function randomGenerateNumber(minRange, maxRange, digits){
    
    noTries = 0;
    while(noTries++ < 100000)
    {
        
        var num = 0;    
        //get a random number from your range
        len = Math.floor(Math.random() * (maxRange - minRange) + minRange);
        //get the lenght of that random number
        len = len.toString().length;
        
        //generate a number with that length using only your set of digits
        while(len--)
        {
            num = num * 10 + digits[Math.floor(Math.random() * digits.length)];                         
        }
        
        if(num >= minRange && num<= maxRange)
        {
            return num;
            break;
        }                   
    }                   
}

//your testing cases
console.log(randomGenerateNumber(100,900,[7,8]))
console.log(randomGenerateNumber(299,300,[1,2,3,4,5,6,7,8,9]));

i did it. Is there any improvement. Little bit messy.

const getRandomNumber = (min: number, max: number, numbers: number[]): number => {
  if (numbers.length === 9) {
    return Math.floor(Math.random() * (max - min + 1) + min);
  }
  let result = '';

  //split maxDigits 100 => [1, 0, 0]
  const maxDigits = max
    .toString()
    .split('')
    .map(i => parseInt(i, 10));

  //split minDigits 100 => [1, 0, 0]
  const minDigits = min
    .toString()
    .split('')
    .map(i => parseInt(i, 10));

  //length of random number [minDigit, maxDigit] inclusive
  const randomDigit = Math.floor(Math.random() * (maxDigits.length - minDigits.length + 1) + minDigits.length);

  let alreadyHigh = false;

  let alreadyLow = false;

  let equal = true;

  //4 conditions

  //1. minDigits.length === maxDigits.length
  //2. randomDigit === minDigits.length
  //3. randomDigit === maxDigits.length
  //4. randomDigit > minDigits.length && randomDigit < maxDigits.length

  for (let i = 0; i < randomDigit; i++) {
    const numbersToUse = i === 0 ? numbers : [...numbers, 0];
    let availableNumbers = [];

    if (minDigits.length === maxDigits.length) {
      if (equal) {
        for (let k = 0; k < numbersToUse.length; k++) {
          if (minDigits[i] > maxDigits[i]) {
            if (numbersToUse[k] >= 0 && numbersToUse[k] <= maxDigits[i]) {
              availableNumbers.push(numbersToUse[k]);
            }
          } else if (numbersToUse[k] >= minDigits[i] && numbersToUse[k] <= maxDigits[i]) {
            availableNumbers.push(numbersToUse[k]);
          } else {
            availableNumbers.push(maxDigits[i]);
          }
        }
      } else {
        if (!alreadyHigh) {
          for (let k = 0; k < numbersToUse.length; k++) {
            if (numbersToUse[k] >= minDigits[i]) {
              availableNumbers.push(numbersToUse[k]);
            }
          }
        } else {
          availableNumbers = numbersToUse;
        }
      }
    } else if (randomDigit === minDigits.length) {
      if (!alreadyHigh) {
        for (let k = 0; k < numbersToUse.length; k++) {
          if (numbersToUse[k] >= minDigits[i]) {
            availableNumbers.push(numbersToUse[k]);
          }
        }
      } else {
        availableNumbers = numbersToUse;
      }
    } else if (randomDigit === maxDigits.length) {
      if (!alreadyLow) {
        for (let k = 0; k < numbersToUse.length; k++) {
          if (numbersToUse[k] <= maxDigits[i]) {
            availableNumbers.push(numbersToUse[k]);
          }
        }
      } else {
        availableNumbers = numbersToUse;
      }
    } else {
      availableNumbers = numbersToUse;
    }

    availableNumbers = [...new Set(availableNumbers)];
    const randomIndex = Math.floor(Math.random() * availableNumbers.length);
    result += `${availableNumbers[randomIndex]}`;

    alreadyHigh = !alreadyHigh ? availableNumbers[randomIndex] > minDigits[i] : true;
    alreadyLow = !alreadyLow ? availableNumbers[randomIndex] < maxDigits[i] : true;
    equal = equal ? availableNumbers[randomIndex] === maxDigits[i] : false;
  }
  return parseInt(result, 10);
};