¡Te damos la bienvenida a este reto!

1

¡Bienvenido al mundo de JavaScript!

Día 1

2

Variables, funciones y sintaxis básica

3

Tipos de datos

4

Playground - Retorna el tipo

5

Tipos de datos - pt 2

Día 2

6

Operadores

7

Hoisting y coerción

8

Playground - Calcula la propina

9

Alcance de las variables

Día 3

10

Condicionales

11

Playground - Calcula años bisiestos

12

Switch

13

Playground - Obten información de mascotas según su tipo

14

Ciclos

15

Playground - Dibuja un triangulo

Día 4

16

Arrays

17

Playground - Encuentra al michi mas famoso

18

Objetos

19

Playground - Obten el promedio de los estudiantes

Día 5 - Checkpoint

20

Playground - encuentra el palindromo más grande

Día 6

21

Reasignación y redeclaración

22

Modo estricto

Día 7

23

Debugging y manejo de errores

24

Programación funcional

Quiz: Día 7

Día 8

25

Closures

26

Playground - Crea una calculadora con closures

27

Higher order functions

28

Playground - Crea tu propio método map

Día 9

29

ECMAScript

30

TC39

Quiz: Día 9

Día 10 - Checkpoint

31

ES6

32

ES7

33

Playground - Task planner

Día 11

34

Asincronismo

35

Playground - Promesas

36

Manejando el asincronismo

37

Playground - Resuelve el callback hell usando promesas

38

Playground - Resuelve el callback hell usando async/await

Día 12

39

Arrays a profundidad

40

Métodos de arrays: Every, Find y findIndex

41

Playground - Válida el formulario

Día 13

42

Métodos de arrays: Includes, Join y concat

43

Playground - agrupa los productos

44

Métodos de arrays: Flat y FlatMap

45

Playground - Encuentra la ubicación del valor buscado

Día 14

46

Mutable functions

47

Playground - Modifica una lista de compras

48

Métodos de arrays: sort

49

Playground - Ordena los productos

Día 15 - Checkpoint

50

Playground - Sistema de reservaciones de un hotel

Día 16

51

Programación orientada a objetos en JavaScript

52

Objetos literales

53

Playground - Congela el objeto recursivamente

Día 17

54

Prototipos en JavaScript

55

Playground - Modifica el prototype de los arrays

56

Playground - Crea un auto usando clases

Día 18

57

Abstracción en JavaScript

58

Playground - Sistema de carrito de compras

59

Encapsulamiento en JavaScript

60

Playground - Encapsula datos de los usuarios

Día 19

61

Herencia en JavaScript

62

Playground - Jerarquía de animales

63

Polimorfismo en JavaScript

64

Playground - Sistema de pagos

Día 20 - Checkpoint

65

Playground - Agenda de vuelos

Live Class

66

30 días de JS con Juan DC

67

30 días de JS con Nicobytes

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Aprende todo un fin de semana sin pagar una suscripción 🔥

Aprende todo un fin de semana sin pagar una suscripción 🔥

Regístrate

Comienza en:

3D
20H
40M
13S

Playground - Promesas

35/67

Aportes 60

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

o inicia sesión.

🛡️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 💪

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);

  });
}

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.

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)
  })
}

/ᐠ。ꞈ。ᐟ\

export function sendEmail(email, subject, body) {
  return new Promise((resolve, reject) => {
    if (email === '' || subject === '' || body === '') {
      reject(new Error('Rellena todos los campos para enviar el correo'))
    } else {
      window.setTimeout(() => {
        resolve({
          'email': email,
          'subject': subject,
          'body': body
        })
      }, 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 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.

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)
  })
}
undefined