Playground - Promesas

🛡️Escudo anti-spoilers🛡️

/
Las promesas son uno de esos temas que te recomienda ver más de una vez porque te van a volar la cabeza más a futuro. Te dejo el curso de asincronismo en JavaScript para que lo puedas entender mejor y te prometo que estos ejercicios se volverán más sencillos… o no 😉
/
Después del gif tendrás la solución explicada a este ejercicio 👇

Explicación 📖

Ahora sí, aquí tienes la explicación

export function sendEmail(email, subject, body) {
  // De entrada empezamos retornando una promesa
  // La cual nos provee de resolve y reject dependiendo si hay éxito en esta
  return new Promise((resolve, reject) => {
    // Primero validamos que todos los aspectos del email estén disponibles
    if (email && subject && body) {
      // De ser así, creamos un timeout para "enviar" el email
      // Recuerden hacer uso de window para que las pruebas pasen
      window.setTimeout(() => {
        // Dentro del timeout definimos un objeto con
        // todos los datos recibidos
        const emailInfo = {
          email,
          subject,
          body,
        };

        // Y lo pasamos a la resolución exitosa de la promesa
        // Para que esto sea "enviado" después de 2 segundos
        resolve(emailInfo);
      }, 2000);
    } else {
      // En caso de faltar algún dato, lanzamos un error indicándolo
      reject(new Error("Hacen falta datos para poder enviar el correo"));
    }
  });
}

Creo que al menos esta promesa es fácil de entender sin la explicación, de igual manera, te invito a que compartas tu solución y nos dejes cualquier duda que tengas respecto a esta solución o problema 💪

Aquí mi solución.
En el mensaje de error también se muestra qué campos faltan.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  const emailBlock = { email, subject, body };

  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => resolve(emailBlock), 2000);
    }
    else {
      const missing = Object.keys(emailBlock).filter(item => emailBlock[item] == false);
      if (missing.length == 1) {
        reject(new Error(`Falta el campo ${missing[0]} para enviar el mensaje`));
      }
      else{
        reject(new Error(`Faltan los campos ${new Intl.ListFormat('es').format(missing)} para enviar el mensaje`));
      }
    }
  });
}

De este video aprendí que Intl.ListFormat().format() devuelve una cadena con los elementos del arreglo según el lenguaje. Para el español agrega (por defecto) la conjunción “y” antes del último elemento.

estuvo bueno el playground!
*
*
*
*
*
*
*
*
*

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Faltan campos por rellenar"))
    } else {
      window.setTimeout(() => {
        const result = { email, subject, body };
        resolve(result);
      }, 2000);
    }
  });
 }

Mi solucion con algunos** cositas extras**:

Operador ternario

filter(Boolean)

“[email, subject, body].filter(Boolean).length == 3” es una comprobación que verifica si se han rellenado los campos necesarios. La función “filter” elimina cualquier valor falso de la lista de campos (como si alguno de los campos fuera null, undefined, o una cadena vacía) y si hay tres elementos, significa que se han rellenado los campos necesarios.

Tambien use el operador ternario para hacer el codigo en menos lineas.

En cada reto aprendo un montón.

<
import { doTask1, doTask2, doTask3 } from './tasks';
export function runCode() {
    return new Promise((resolve, reject) => {
        if (!email || !subject || !body) {
          reject(new Error("Hacen falta campos para enviar el email"));
        } else if (!/\S+@\S+\.\S+/.test(email)) {
          reject(new Error("El correo electrónico proporcionado no es válido"));
        }
        setTimeout(() => {
          resolve({ email, subject, body });
        }, 2000);
      });     
 }
> 

Resolviendo promesas… 😃

function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  const mail = {
    email,
    subject,
    body
  }

  return new Promise((resolve, reject) => {
    for (let prop in mail) {

      if (mail[prop].trim() == "") {
        window.setTimeout(() => {
          reject(new Error("Error: Hacen falta campos para enviar el email"))
        }, 2000);
      }
    }
    window.setTimeout(() => {
      resolve(mail);
    }, 2000);

  });
}

Este es un escudo anti spoiler
.
.
.
.
.
.
.
.
.
.
.
.
.

Toma tu tiempo en crear buenas validaciones, ahí esta la clave en este código.

Mi aporte:

Prometeme que no te rendirás

Pero si no cumples tu promesa, te dejo mi solución

function sendEmail(email, subject, body) {
    return new Promise((resolve, reject) => {
        if (email !== "" && subject !== "" && body !== "") {
            window.setTimeout(() => {
                resolve({
                    email: email,
                    subject: subject,
                    body: body
                })
            }, 2000);
        }
        else {
            if (email === "" || subject === "" || body === "") {
                reject(new Error("Error: Hacen falta campos para enviar el email"));
            }
        }
    })
}

Only running in console:

function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    const arrayResponse = {email, subject, body};
    if (!email || !subject || !body) {
      setTimeout(() => {
        reject(new Error("Hacen falta campos para enviar el email"));
      }, 2000);
    } else {
      setTimeout(() => {
        resolve(arrayResponse);
      }, 2000);
    }
  });
}

Input after 2 seconds:

//Promise Resolved
sendEmail("[email protected]", "Nuevo reto", "Únete a los 30 días de JS")
  .then((result) => console.log(result))
  .catch((error) => console.log(error));
//Promise Rejected
sendEmail("[email protected]", "", "Únete a los 30 días de JS")
  .then((result) => console.log(result))
  .catch((error) => console.log(error));

Output after 2 seconds:

{
  email: '[email protected]',
  subject: 'Nuevo reto',
  body: 'Únete a los 30 días de JS'
}
Error: Hacen falta campos para enviar el email

Aporte de mi solucion!
.
.
.
.
.
.
.
.
.
.
.

🛡️🛡️🛡️Escudo anti spoilers🛡️🛡️🛡️

Promesas

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email != "" && subject != "" && body != "") {
      setTimeout(() => {
        resolve({
          email,
          subject,
          body,
        });
      }, 2000);
    } else {
      setTimeout(() => {
        reject(new Error("Hacen falta campos para enviar el email"));
      }, 2000);
    }
  });
}

Mi solución:

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email == "" || subject == "" || body == "") {
      reject(new Error("Error: Hacen falta campos para enviar el email"))
    }
    else {
      window.setTimeout(() => resolve({
        email: email,
        subject: subject,
        body: body,
      }), 2000)
    }
  }

  )
}

mi solución:
🪄
🪄
🪄
🪄
🪄
🪄
🪄

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (email && subject && body) {
        resolve({
          email,
          subject,
          body,
        })
      } else {
        reject(new Error("Error: Hacen falta campos para enviar el email"))
      }
    },2000)
  })
}

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => { 
    if (email && subject && body) {
      window.setTimeout(() => {
        resolve({email, subject, body})
      }, 2000);
    } else {
      reject(new Error("Datos incompletos para enviar correo"));
      return;
    }
  });
}

Mi solución pequeñita 💚

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Error: Hacen falta campos para enviar el email"))
      return;
    }

    window.setTimeout(() => {
      resolve({email, subject, body})
    }, 2000)
  })
}

export function sendEmail(email, subject, body) {
  const message = "Hacen falta campos para enviar el email";
  const MILLISECONDS = 2000;
  const falsyValues = [null, ""];

  let mail = { email, subject, body }
  
  const rejectCondition = falsyValues.includes(email) || 
				       					  falsyValues.includes(subject) || 
													falsyValues.includes(body);

  return new Promise ( 
(resolve, reject) => rejectCondition ? 
						 reject(new Error(message)) :
						 window.setTimeout(() => resolve(mail), MILLISECONDS)
  )

}

.
.
.
.
.
.

export function sendEmail(email, subject, body) {
    const promise = new Promise((resolve, reject) => {
      if (email && subject && body) {
        window.setTimeout(() => {
          const fullEmail = { email, subject, body };
          resolve(fullEmail);
        }, 2000)
      } else {
        window.setTimeout(() => {
          reject(new Error('Error: Hacen falta campos para enviar el email'));
        }, 2000)
      }
    });
    return promise;
}

Hola, aquí dejo mi solución 😃
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈

  return new Promise((resolve, reject) => { 

    if (email == "" || subject == "" || body == "") {
      const message = "Faltan campos para enviar el correo";
      reject(new Error(message));
    } else { 
      window.setTimeout(() => { 

        let correo = {
          email: email,
          subject: subject,
          body: body
        }

        resolve(correo);
      }, 2000);
    }

  }

  );
}

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => {
        resolve({ email, subject, body });
      }, 2000);
    } else {
      reject(new Error('Fatan datos para enviar el correo'));
    }
  });
}

Mi solución

function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    const isNotAEmail = email == '' || subject == '' || body == ''
    if (isNotAEmail) {
      reject(new Error('Hacen falta campos para enviar el mensaje'))
    } else {
      setTimeout(() => {
        const message = {
          email: email,
          subject: subject,
          body: body
        }
        resolve(message)
      }, 2000)
    }
  })
}

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => {
        resolve({ email: email, subject: subject, body: body });
      }, 2000)
    } else {
      reject(new Error("There are missing fields"))
    }
  })
}

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => {
        const emailData = {
          email,
          subject,
          body,
        };
        resolve(emailData);
      }, 2000);
    } else {
      reject(new Error("Hace falta datos requeridos para enviar el correo"));
    }
  });
}

👾 Mi solución

🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email === "" || subject === "" || body === "")
      reject(new Error("Error: Hacen falta campos para enviar el email"));

    window.setTimeout(() => {
      resolve({
        email,
        subject,
        body,
      });
    }, 2000);
  });
}

Mi aporte (Spoiler)
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
export function sendEmail(email, subject, body) {
// Tu código aquí 👈
return new Promise((resolve, reject) => {
if (email != “” && subject != “” && body != “”) {
const resp = {email: email, subject: subject, body: body};
window.setTimeout(() => {
resolve(resp)
}, 2000);
}
else {
reject(new Error(“Error: Hacen falta campos para enviar el email”));
}
})
}

Hola comparto mi solución, dejo estos robots antispoiler.

🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖
🤖

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email === undefined || email.length === 0) {
        reject(new Error("Error email is missing"));
      }

      if (subject === undefined || subject.length === 0) {
        reject(new Error("Error subject is missing"));
      }

      if (body === undefined || body.length === 0) {
        reject(new Error("Error body is missing"));
      }

      resolve({ email, subject, body });
    }, 2000);
  });
}

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Error: Hacen falta campos para enviar el email"));
    } else {
      window.setTimeout(() => {
        
        const data = { email, subject, body }
        resolve(data)
      }, 2000);
    }
  })
}

¡Hola 😃!
Mi solución,
Se detalla hasta abajo.⬇
⬇
⬇
⬇
⬇
⬇
⬇
⬇
⬇
⬇
⬇
⬇

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email.trim().length != 0 && subject.trim().length != 0 && body.trim().length != 0) {
      window.setTimeout(() =>
      {
        resolve(
          {
          email,subject,body,
          }
        );
      }, 2000);
    } else
    {
     reject(new Error("Falta datos para poder enviar el correo"));
    }
  });
}

Lo hice casi igual, solo que la validacion la hice opuesta, primero valide si hay errores y luego si esta todo bien es que avanza

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error('Hacen falta campos para enviar el email'))
    } else {
      window.setTimeout(() => {
        const result = {
          email: email,
          subject: subject,
          body: body
        }
        resolve(result)
          .then(res => console.log(res))
          .catch(error => console.log(error))
      },2000)
    }
  })
}

Mi solucion

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (!email || !subject || !body) {
        reject(new Error("Hacen falta campos para enviar el email"));
      } else {
        resolve({
          email,
          subject,
          body
        })
      }
      
    }, 2000)
  })
}

Mi solución

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email === "" | subject === "" | body === "") {
        reject(new Error("Error: Hacen falta 		 
        campos para enviar el email"));
      } else {
        resolve({ email: email, subject: subject, 
        body: body });
      }
    }, 2000);
  });
}

mi solución es:

// Tu código aquí 👈
    const result = {
        email:email,
        subject:subject,
        body:body,
    }
    console.log(email.length + subject.length + body.length)
    return new Promise((resolve, reject) => {
        if (email=="" ||  subject=="" ||  body=="" ){
            reject(new Error("Error: Hacen falta campos para enviar el email"));
        }else{
            window.setTimeout(() => {
                resolve(result);
            }, 2000);
        }
    });

Hola mi gente, llegue a este resultado.

    email: `${email}`,
    subject: `${subject}`,
    body: `${body}`
  };
  
  return new Promise((resolve, reject) => {

    for (const key in result) {
      if (Object.hasOwnProperty.call(result, key)) {
        if (result[key] == "") {
          reject(new Error("Erro faltaron Datos"));
        }

      }
     
    }
    window.setTimeout(() => {
      resolve((result));
    },2000);

  }); ```

🛡️Escudo anti-spoilers🛡️

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body){
        reject(new Error('Error, faltan campos para enviar el correo'))
    }else{
        window.setTimeout(() => resolve({email,subject,body}), 2000)
    }
  })
}

Mi solución:

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Hacen falta campos para enviar el email"));
    } else {
      window.setTimeout(() => {
        const result = {
          email,
          subject,
          body,
        }
        resolve(result);
      }, 2000);
    }
  });
}

Comparto mi solución al reto:
💪
💪
💪
💪
💪
💪
💪
💪
💪
💪
💪
💪
💪
💪

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email === '' || subject === '' || body === '') {
        reject(new Error('Error: Hacen falta campos para enviar el email'))
      }
      else {
        resolve({
          email: email,
          subject: subject,
          body: body,
        })
      }
    }, 2000);
  })
}

export const sendEmail = (email, subject, body) => {
  return new Promise((result, reject) => {
    window.setTimeout(() => {
      email = email == undefined || email == null ? '' : email.trim();
      subject = subject == undefined || subject == null ? '' : subject.trim();
      body = body == undefined || body == null ? '' : body.trim();

      if (email == '' || subject == '' || body == '') {
        reject(new Error('Error: Hacen falta campos para enviar el email'))
      } else {
        result({ email, subject, body });
      }
    }, 2000);
  })
}

Aporto mi solución…
.
.
.
…
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      const error = new Error("Hacen falta campos para enviar el email");
      reject(error);
    } else {
      window.setTimeout(() => {
        const emailData = { email, subject, body };
        resolve(emailData);
      }, 2000);
    }
  });
}

Hola. Comparto mi solución comentada
.
.
.
.
.
.
.
.
.
.
.

function sendEmail(email, subject, body) {
    // creación y retorno de la promesa
    return new Promise((resolve, reject) => {
        // validación de exitencia de los elementos
        if (!email || !subject || !body)
            // creación del error y ejecución de reject
            reject(new Error("Hacen falta campos"))
        // declaración del temporizador y ejecución del resolve
        window.setTimeout(() => {
            resolve({ email, subject, body })
        },2000)
    })
}

dejo mi solución por aquí.

.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {

  const promise = new Promise((resolve, reject) => {
    if (email === "" || subject === "" || body === "") {
      reject(new Error("Error: Hacen falta campos para enviar el email"))
    } else {
      window.setTimeout(() => {
        resolve({ email: email, subject: subject, body: body });
      }, 2000);
    }
  });
  return promise
}

Solución

function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
  	
    window.setTimeout(() => {
    	
      if (email == "" || subject == "" || body == "") {
    		reject(new Error("Hacen falta campos para enviar el email"))
    	}
      // Resolving

    	resolve({email, subject, body})
    },2000)
  })
}

Buenas, dejo mi aporte por aquí…
.
.
.
.
.
.
.
.
.
.
…
.
.
.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (!(email && subject && body)) reject(new Error("Error: Hacen falta campos para enviar el email"));
    window.setTimeout(() => {
      resolve({ email: email, subject: subject, body: body });
    }, 2000);
  });
}

function sendEmail(email, subject, body) {

  return new Promise((resolve, reject) => {
    if (email === "" || subject === "" || body === "") {
      reject(new Error("Error: Hacen falta campos para enviar el email"));
      return;
    }

    window.setTimeout(() => {
      const mail = { email, subject, body };
      resolve(mail);
    }, 2000);
  });
}

Yo llegué a la siguiente solución:

function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Error: Hacen falta campos para enviar el email"));
    } else {
      window.setTimeout(() => resolve({ email, subject, body }), 2000);
    }
  })
}

Mi solución:

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
    reject(new Error("Hacen falta campos para enviar el email"));
    } else {
      window.setTimeout(() => {
        resolve({
          "email": email,
          "subject": subject,
          "body": body
        })
      }, 2000)
    }
  })
}

export function sendEmail(email, subject, body) {
  
     return new Promise((resolve, reject) => {
      if (email === "" || subject === "" || body === "") {
        reject(new Error("Hacen falta campos para enviar el email"));
      } else {
        window.setTimeout(() => {
          resolve({
            body,
            email,
            subject
          });
        }, 2000);

      }
    });


}

Aquí va mi solución que la verdad no es nada diferente a la presentada por Leo, pero lo bueno que me está sirviendo esto para ver, codear y aprender mejor JavaScript con estos retos!!

function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => {
        const emailInfo = {
          email,
          subject,
          body,
        };
        resolve(emailInfo);
      }, 2000);
    } else {
      reject(new Error("Faltan datos para poder enviar el correo"));
    }
  });
}

Listo, otro mas superado

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => {
        resolve({ email, subject, body });
      }, 2000);
    } else {
      reject(new Error('Hacen falta campos para enviar el email'));
    }
  })
}

function sendEmail(email, subject, body) {

    return new Promise((resolve, reject) => {

      if (email !== "" && subject !== "" && body != "") 
      {
        setTimeout(() => {
          resolve({ email, subject, body });
        }, 2000)
      } else {
        reject('errorrrr')
      }
    });

}

sendEmail(
    "[email protected]",
    "Nuevo reto",
    "Únete a los 30 días de JS"
  )
  .then(result => console.log(result))

  sendEmail(
    "[email protected]",
    "",
    "Únete a los 30 días de JS"
  )
  .then(result => console.log(result))
  .catch(error => console.log(error))

the truth sol:

export function sendEmail(email, subject, body) {
  const message = "Hacen falta campos para enviar";
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email != "" && subject != "" && body != "") {
        resolve({
          email,
          subject,
          body
        })
      } else {
        reject(new Error(message));
      }
    }, 2000)
  })
}

function sendEmail(email, subject, body) {
    // Tu código aquí 👈
    return new Promise((resolve, reject) => {
        if (!email || !subject || !body) {
            reject(new Error("Error: Hacen falta campos para enviar el email-"));
        } else {
            setTimeout(() => {
               // console.log({email,subject,body});
             resolve({email,subject,body})
            }, 2000);
        }
    })
}
sendEmail(
    "[email protected]",
    "",
    "Únete a los 30 días de JS"
  )
  .then(result => console.log(result))
  .catch(error => console.log(error))

Esta es mi resolución al reto:
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email = "", subject = "", body = "") {
  let missingEmail = email === ""
  let missingSubject = subject === ""
  let missingBody = body === ""

  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (!missingEmail && !missingSubject && !missingBody) {
        resolve({ email, subject, body });
      }
      else {
        reject(new Error("Hacen falta campos para enviar el email"));
      }
    }, 2000)
  })
}

Aquí está mi solución…
.
.
.
.
.
.
.
.
.
.
.
.
.

Mi humilde solución:

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    email.length === 0 || subject.length === 0 || body.length === 0 ?
      reject(new Error("Error: Hacen falta campos para enviar el email"))
      : window.setTimeout(() => {
        let correo = { email: email, subject: subject, body: body };
        resolve(correo);
      }, 2000);
  });
}

Mi aporte:

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      let res = {
        email: email,
        subject,
        body
      }
      window.setTimeout(() => {
        resolve(res);
      }, 2000)

    } else {
      window.setTimeout(() => {
        reject(new Error("Error: Hacen falta campos para enviar el email"))
      }, 2000)
}
  })
}

Mi aporte, comparando con el de otros/as compas, creo que yo inicié el if al contrario pero ajá, el orden de los factores nos dio el mismo resultado :B

.
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email === "" || subject === "" || body === "") {
      reject(new Error("Error: Hacen falta campos para enviar el email"));
    } else {
      window.setTimeout(() => {
        const correo = {
          "email": email,
          "subject": subject,
          "body": body,
        };
        resolve(correo);
      }, 2000);
    }
    })
}

mi unico y especial code

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    let toSend = {}
    const args = [...arguments]
    const isAllOk = args.map(arg => Boolean(arg != '')).some(item => item === false)

    if (isAllOk != true) {
      toSend = { email: email, subject: subject, body: body }
      window.setTimeout(() => resolve(toSend), 2000)

    } else {
      window.setTimeout(() => reject(new Error('Hacen falta campos para enviar el email')), 2000)
    }
  })
}

.
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise(
    (resolve, reject) => {
      if (email && subject && body) {
        window.setTimeout(() => {
          resolve(
            {
              email: email,
              subject: subject,
              body: body
            }
          );
        }, 2000);

      } else {
        reject(new Error("Error: Hacen falta campos para enviar el email"));
      }

    }
  )
}

Mi código del ejercicio.
.
.
.
.
.

.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => {
        const emailParameter = {
          "email": email,
          "subject": subject,
          "body": body
        }
        resolve(emailParameter)
      }, 2000);
    }
    else
      reject(new Error("Error: Hacen falta campos para enviar el email"))
  });
}
 

export function sendEmail(email, subject, body) {
  const promise = new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email && subject && body)
        resolve({ email: email, subject: subject, body: body });
      else
        reject(new Error("faltan campos para enviar el correo"));
    }, 2000);
    
  });
  return promise;
}

Comparto mi solucion

MI SOLUCION 💪
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Error: Hacen falta campos para enviar el email"));
    } else {
      window.setTimeout(() => {
        resolve({
          email,
          subject,
          body
        });
      }, 2000);
    }
  });
}

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => { 
      if (email && subject && body) {
        const emailInfo = {email, subject, body};
        resolve(emailInfo);
      }
      else {
        reject(new Error("Hacen falta campos para enviar el email"));
      }
    }, 2000)
  })
}

Comparto mi solución:
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Hacen falta campos para enviar el email"))
    }
    else {
      window.setTimeout(() => {
        resolve({email, subject, body})
      }, 2000)
    }
  })
}

Comparto mi solución. Lo que lo hace diferente respecto a la de LeoCode. Es qué especifíque el campo que hace falta mandando un error personalizado por cada argumentos que recibimos.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email !== "") {
      if (subject !== "") {
        if (body !== "") {
          window.setTimeout(() => {
            resolve({ email: email, subject: subject, body: body})
          }, 2000)
        } else {
          reject(new Error("Hace falta el cuerpo del correo"))
        }
      } else {
        reject(new Error("Hace falta el asunto del correo"))
      }
    } else {
      reject(new Error("Hace falta el correo"))
    }
  })
    
}

Mi solución:

export function sendEmail(email, subject, body) {
  return new Promise(function (resolve, reject) {
    if (email && subject && body) {
      window.setTimeout(() => {

        const emailInfo = {
          email:email, subject:subject, body:body
        };

        resolve(emailInfo);
      },2000);
    }
    else { 
      window.setTimeout(() => {
        reject(new Error("Hacen falta campos para enviar el email"))
      }, 2000);
    }
  });
}

Mi solucion:

Solución… 😄
.
Algo interesante, es que se puede devolver el objeto de la siguiente manera:
.

{email, subject, body} 

.
En lugar de:
.

{
  email: email,
  subject: subject,
  body: body
}

.
En JavaScript, si la variable y la propiedad de un objeto tienen el mismo nombre, puede utilizar la sintaxis de asignación de objetos abreviada para asignar el valor a la propiedad del objeto.
.
El resultado sería un objeto con tres propiedades: “email”, “subject” y “body”, con los valores que se hayan asignado a las variables correspondientes. Por ejemplo, si email es “[email protected]”, subject es “Asunto del correo” y body es “Cuerpo del correo”, entonces el objeto se vería así:
.

{
  email: "[email protected]",
  subject: "Asunto del correo",
  body: "Cuerpo del correo"
}

.
Código:
.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => { 
    if (!email || !subject || !body) {
      reject(new Error("Hacen falta campos para enviar el email"));
    } else { 
      window.setTimeout(() => { 
        resolve({email, subject, body});
      }, 2000);
    }
  });
}

.

Buenas, comparto mi solución
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email && subject && body) {
      window.setTimeout(() => {
        resolve({
          email,
          subject,
          body
        })
      }, 2000);
    }
    else {
      reject(new Error("Error: Hacen falta campos para enviar el email"));
    }

  })
}

Les presento mi solución, para hacer las validaciones de los parámetros vacíos y el codigo sea reutilizable por si en un futuro a la función se envían mas parámetros que conformaran el objeto que los englobara usé Object.values y el metodo some().
.
.
.

function sendEmail(email, subject, body) {
  let emailObj = { email, subject, body }
  return new Promise((resolve, reject) => {
    if (Object.values(emailObj).some(ele => ele == "")) {
      reject(new Error("Hacen falta campos para enviar el email"))
    } else {
      window.setTimeout(() => {
        resolve(emailObj)
      },2000)
    }
  })
}

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

Comparto mi solución:

function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  let respuesta = {
    email,
    subject,
    body
  }

  return new Promise((resolve, reject) => {

    if (!respuesta.email || !respuesta.subject || !respuesta.body) {
      reject(new Error("Error: Hacen falta campos para enviar el email"));

    } else {

      setTimeout(() => {

        resolve(respuesta)
      }, 2000)
    }


  })
};

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
solo dire que me falta practicarlo mucho mas para dominarlo, lo bueno es que tienen retos de asincronismo y eso me motiva

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email === "" || subject === "" || body === "") {
        reject(new Error("Hacen falta campos para enviar el email"));
      }
      else {
        resolve({ email, subject, body });
      }
    }, 2000);
  });
  
}

Aquí mi solución mis panas frescos, es chiquita pero poderosa:

.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  return new Promise(
    (resolve, reject) => {
      window.setTimeout(() => {
        (email && subject && body) ? resolve({ email, subject, body }) :
          reject(new Error('Hacen falta campos para enviar el email'))
      }, 2000)
    }
  )
}

Solución

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (!email || !subject || !body) {
      reject(new Error("Faltan campos para enviar el correo"));
    } else {
      window.setTimeout(function () {
        resolve({ email, subject, body });
      }, 2000);
    }    
  })
}

MI solución:

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email&&subject&&body !== "") {
      window.setTimeout(() => {
        resolve({ email, subject, body });
      }, 2000);
    } else {
      reject(new Error("Hacen falta campos para enviar el email"));
    }
  });
}

Aun no había llegado al curso de promesas, y la verdad tenía algo de temor al respecto; sin embargo, creo que como todo, es simplemente de práctica y dedicación:

Mi solución.
Al principio solo verifico que los datos no estén vacíos, sino mandar el error en el reject.
Sino uso el setTimeout para devolver los datos con resolve en una clase y que se retornen pasados dos segundos.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email == "" || subject == "" || body == ""){
      reject(new Error("Hacen falta campos para enviar el email"));
    }
    window.setTimeout(() => {
      resolve({email, subject,body});
    }, 2000)
  })
}

Hola, dejo mi solucion
Caminito anti spoilers
🚗
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Llegamos 📍

export function sendEmail(email, subject, body) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (email === "" || subject === "" || body === "") {
      reject(new Error("Hacen falta campos para enviar el email"));
    } else {
      window.setTimeout(() => {
        resolve({ email, subject, body });
      }, 2000);
    }
  });
}

Adjunto mi solución:
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email.trim() && subject.trim() && body.trim()) {
        resolve({
          email,
          subject,
          body
        })
      } else {
        reject(new Error('Hacen falta campos para enviar el email'))
      }
    }, 2000)
  })
}

Mi solucion:
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      let params = [email, subject, body];
      if (params.some(el => el == "" || el == undefined)) {
        return reject(new Error("Hacen falta campos para enviar el email"));
      }

      return resolve({ email, subject, body });
    }, 2000);
  })
}

Aporte
.
.
.
.
.
.
.
.
.
.

function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (email !== '' && subject !== '' && body !== '') {
        resolve({ email: email, subject: subject, body: body });
      } else {
        reject(new Error("Error: Hacen falta campos para enviar el email"));
      }
    }, 2000)
  })
}

Este tema se me complica un poco, pero ahí vamos mejorando
.
.
.
.
.
.
.
.
.
.

    export function sendEmail(email, subject, body) {
      return new Promise((resolve, reject) => { 
        if (!email || !subject || !body) {
          reject(new Error("faltan campos para enviar el correo"))
        }
        else { 
          window.setTimeout(() => { 
            resolve({
              "email": email,
              "subject": subject,
              "body": body
            })       
          }, 2000);
        }
      })
    }

Aporto mi solución
.
.
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    //Generamos un timeout que se va a ejecutar en 2000ms (2s)
    window.setTimeout(() => {
      //Si el email o asunto o cuerpo está vacío lo rechaza
      if (email == "" || subject == "" || body == "") {
        reject(new Error("Faltan campos para enviar el correo"))
      }
      //Si todos los campos tienen algo, envía el correo
      else {
        resolve({
          'email': email,
          'subject': subject,
          'body': body
        })
      }
    }, 2000)
  })
}

export function sendEmail(email, subject, body) {

  return new Promise((resolved, rejected) => {

    window.setTimeout(() => {
      if (arguments.length === 3 && email != "" && subject != "" && body != "") {

        resolved({
          email: email,
          subject: subject,
          body: body,
        })

      }
      else {
        rejected(new Error("Error: Hacen falta campos para enviar el email"))
      }
    }, 2000)
  })
}

.
. ------------------------------------
. ESCUDO ANTI SPOILER
. 😃
. -------------------------------------
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.

export function sendEmail(email, subject, body) {
  const TWO_SECONDS = 2000
  return new Promise((resolve, reject) =>
    window.setTimeout(() => {
      if (email && subject && body) {
        resolve({ email, subject, body })
      } else {
        reject(new Error("Error: Hacen falta campos para enviar el email"))
      }
    }, TWO_SECONDS)
  )
}

Spoilers:
.
.
.
.
.
.
.
.
.
.

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      if (!email || !subject || !body) {
        reject(new Error("Error: Hacen falta campos para enviar el email"));
      } else {
        resolve({
          email: email,
          subject: subject,
          body: body
        })
      }
    }, 2000)
  })
}