cdwUniapp/libs/utils/isPending.js

/**
 * 检查目标是否为pending状态的Promise或异步函数
 * @param {*} target 要检查的目标，可接受Promise、异步函数或同步函数
 * @returns {Promise<boolean>} 一个Promise，解析为目标是否为pending状态
 */
async function isPending(target) {
  // 如果是异步函数，执行后检查返回的Promise状态
  if (isAsyncFunction(target)) {
    try {
      const promise = target();
      return await checkPromisePending(promise);
    }
    // eslint-disable-next-line unused-imports/no-unused-vars
    catch (error) {
      return false; // 异步函数执行出错，不是pending状态
    }
  }

  // 如果是Promise对象，直接检查状态
  if (isPromise(target)) {
    return await checkPromisePending(target);
  }

  return false; // 既不是异步函数也不是Promise
}

/**
 * 检查是否为异步函数
 * @param {*} fn 要检查的函数
 * @returns {boolean} 是否为异步函数
 */
function isAsyncFunction(fn) {
  return typeof fn === "function"
    && (fn.constructor.name === "AsyncFunction"
      || fn.toString().includes("async"));
}

/**
 * 检查是否为Promise
 * @param {*} obj 要检查的对象
 * @returns {boolean} 是否为Promise
 */
function isPromise(obj) {
  return obj instanceof Promise
    || (obj && typeof obj.then === "function");
}

/**
 * 检查Promise是否为pending状态
 * @param {Promise} promise 要检查的Promise对象
 * @returns {Promise<boolean>} 一个Promise，解析为Promise是否为pending状态
 */
async function checkPromisePending(promise) {
  const pending = Symbol("pending");

  try {
    const result = await Promise.race([
      promise.then(
        () => "fulfilled",
        () => "rejected",
      ),
      Promise.resolve(pending),
    ]);

    return result === pending;
  }
  // eslint-disable-next-line unused-imports/no-unused-vars
  catch (error) {
    return false; // Promise已经rejected
  }
}

/**
 * 检查是否为Promise或异步函数
 * @param {*} target 要检查的目标
 * @returns {boolean} 是否为Promise或异步函数
 */
function isAsync(target) {
  return isPromise(target) || isAsyncFunction(target);
}

export { isAsync, isPending };