limitedRequest.js

let wxRequest = function (params) {
    setTimeout(() => {
      params.success(params.message)
    }, params.time)
}

const limitedRequest = function (max) {
  const LIMIT = max || 5
  const cacheQueue = []
  let count = 0

  function request (params) {
    return (new Promise((resolve, reject) => {
      wxRequest({
        ...params,
        success: (...params) => {
          finishReq()
          resolve(...params)
        },
        fail: (...params) => {
          finishReq()
          reject(...params)
        }
      })
    }))
  }

  function finishReq () {
    count--
    let cacheHead = cacheQueue.shift()
    cacheHead && cacheHead()
  }

  return function (params) {
    if(count > LIMIT) {
      return (new Promise((resolve) => {
        cacheQueue.push(function () {
          resolve(request(params))
        })
      })).then(req => req)
    } else {
      let curReq = request(params)
      count++
      return curReq
    }
  }
}

const limitedReq = limitedRequest()
for (let i = 0; i < 5; i++) {
  limitedReq({
    time: 1000,
    message: 'i = ' + i
  }).then(res => console.log(res))
}

================================
// Without Closure
const LIMIT = max || 5
const cacheQueue = []
let count = 0

function request (params) {
  return (new Promise((resolve, reject) => {
    wxRequest({
      ...params,
      success: (...params) => {
        finishReq()
        resolve(...params)
      },
      fail: (...params) => {
        finishReq()
        reject(...params)
      }
    } 
  }))
}

function finishReq () {
  count--
  let cacheHead = cacheQueue.shift()
  cacheHead && cacheHead()
}

function limitedRequest (params) {
  if(count > LIMIT) {
    return (new Promise((resolve) => {
      cacheQueue.push(function () {
        resolve(request(params))
      })
    })).then(req => req)
  } else {
    let curReq = request(params)
    count++
    return curReq
  }
}

// Aync/await
async function limitedRequestAsync (params) {
    return await limitedRequest(params)
}

export function requestWX(params) {
  return new Promise((resolve, reject) => { // 将该 promise 的状态代理到真实 promise 上。可以保证未激活的 Promise 同样可以拿到结果 
    const task = createTask(request, resolve, reject, params)
    if (count >= LIMIT) {
      cacheQueue.push(task)
    } else {
      task()
    }
  })
}

function createTask (caller, resolve, reject, params) {
  return function () {
    caller(params)
      .then(res => resolve(res))
      .then(err => reject(err))
      .finally(() => {
        count--
        if (cacheQueue.length) {
          let task = cacheQueue.shift()
          task()
        }
      })
    count++
  }
}

What about async/await ?

async function requestWX(params) {
  return await (new Promise.......)
}