Как заставить функцию возвращать обещание, если необязательный обратный вызов не передан?

 async function squareAsync1(val, callback) {
let p = new Promise((resolve, reject) => {
    setTimeout(() => {
        if (Math.random() < 0.5) {
            resolve(val * val);
        }
        else {
            reject(new Error('Failed!'));
        }
    }, 2000);
});
if (callback) {
    return p.then(d => {
        return callback(undefined, d);
    }, e => {
        return callback(e);
    });
 }
return p;
}

Да, ваше решение будет работать с async / await. Обратите внимание, я только что добавил return в p.then

Таким образом вы можете сделать что-то вроде:

const x = await squareAsync1(2, (e, v) => e ? 1 : v * 2)

И вы получите x как 1 (если обещание было отклонено) или 8 (если обещание было успешным).

Сделать это можно так:

function squareAsync(val, callback) {
  const timeout = function(res, rej){
    setTimeout(function(){
      if (Math.random() < 0.5)
        res(val*val);
      else
        rej(new Error('Failed!'));
    }, 2000);
  }
  
  return typeof callback === 'function'
    ? timeout(callback.bind(null, undefined), callback)
    : new Promise(timeout);
}

// CALLBACK EXAMPLE
squareAsync(5, (err, val) => {
  if (err)
    console.info(`Callback: ${err}`);
  else
    console.info(`Callback: ${val}`);
})

// PROMISE EXAMPLE
squareAsync(5)
  .then(val => console.info(`Promise: ${val}`))
  .catch(err => console.info(`Promise: ${err}`))

Объяснение

1. Оберните вызов setTimeout в одну функцию-оболочку timeout, чтобы вам не приходилось повторять почти идентичный код.
2. Пусть функция timeout принимает два аргумента: res и rej(разрешить и отклонить)
3. Вернуть timeout, если обратный вызов передан с функцией, иначе вернуть new Promise(timeout).

Теперь о том, что происходит в:

return typeof callback === 'function'
  ? timeout(callback.bind(null, undefined), callback)
  : new Promise(timeout);

Это переводится как:

if (typeof callback === 'function'){
  // Bind `null` as `this` value to `callback
  // and `undefined` as its first argument (because no error).
  // Need to to this because in `timeout` function,
  // we call `res` with only 1 argument (computed value) if success.
  const resolve = callback.bind(null, undefined);

  // Don't need to bind anything
  // because the first argument should be error.
  const reject = callback;

  // Call the function as if we are in a Promise
  return timeout(resolve, reject);
}

// Use `timeout` function as normal promise callback.
return new Promise(timeout);

Надеюсь, вы понимаете. Не стесняйтесь комментировать, если запутались.

Подробнее о привязке.