wlasna implementacja metody Promise.all

const promiseAll = <T>(arrayOfPromise: Promise<T>[]): Promise<T[]> => {
    const isArrayOfPromisesEmpty = arrayOfPromise.length === 0;
    if (isArrayOfPromisesEmpty) 
     return Promise.resolve([]);
  
    const resolvedPromises: T[] = [];
    let resolvedPromisesCounter = 0;
    return new Promise((resolve, reject) => {
      for (const [index, promise] of arrayOfPromise.entries()) {
        promise
          .then((result) => {
            resolvedPromises[index] = result;
            resolvedPromisesCounter++;
  
            const hasResolvedAllPromises = resolvedPromisesCounter === arrayOfPromise.length
  
            if (hasResolvedAllPromises) {
              resolve(resolvedPromises);
            }
          })
          .catch((error) => {
            reject(error);
          });
      }
    });
  };
  
  const promise = new Promise<string>((resolve,recjet) =>
     setTimeout(() => {
      resolve("GooD")
   }, 1000));
  const promise2 = new Promise<string>((resolve,recjet) =>
    setTimeout(() => {
     resolve("World")
  }, 1000));
  const promise3= new Promise<string>((resolve, reject) =>{
     setTimeout(() =>{
        resolve("!")
     },200)
  
  }
  );
  
  promiseAll([promise, promise2, promise3])
    .then((results) => console.log("Success:", results)) 
    .catch((error) => console.error("Error:", error));

const promiseAll = <T extends readonly unknown[] | []>(arrayOfPromise: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }> => {

/**
 * Recursively unwraps the "awaited type" of a type. Non-promise "thenables" should resolve to `never`. This emulates the behavior of `await`.
 */
type Awaited<T> = T extends null | undefined ? T : // special case for `null | undefined` when not in `--strictNullChecks` mode
    T extends object & { then(onfulfilled: infer F, ...args: infer _): any; } ? // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped
        F extends ((value: infer V, ...args: infer _) => any) ? // if the argument to `then` is callable, extracts the first argument
            Awaited<V> : // recursively unwrap the value
        never : // the argument to `then` was not callable
    T; // non-object or non-thenable

const promiseAll = <T extends unknown[]>(
    arrayOfPromises: [...T]
  ): Promise<{ [K in keyof T]: Awaited<T[K]> }> => {
    const isArrayEmpty = arrayOfPromises.length === 0;
    if (isArrayEmpty) return Promise.resolve(arrayOfPromises as { [K in keyof T]: Awaited<T[K]> });
  
    return new Promise((resolve, reject) => {
      const quantityOfElementsInInputArray = arrayOfPromises.length;
      const results = new Array(quantityOfElementsInInputArray) as { [K in keyof T]: Awaited<T[K]> };
      let promiseCounter = 0;
  
      for (const [index, promise] of arrayOfPromises.entries()) {
        const currentIndex = index;
        Promise.resolve(promise)
          .then((result) => {
            results[currentIndex] = result as Awaited<T[typeof index]>;
            promiseCounter++;
  
            if (promiseCounter === quantityOfElementsInInputArray) {
              resolve(results);
            }
          })
          .catch(reject);
      }
    });
  };



promiseAll(arrayOfPromises).then(console.log)
Promise.all(arrayOfPromises)

// Tu zrobisz typ w jakiej postacji chcesz aby Promise został mapowany 

type CustomResult = {
  value: number;
};

function myPromiseAll(promises: (number | Promise<number>)[]): Promise<CustomResult[]> {
  return new Promise((resolve, reject) => {
    if (!Array.isArray(promises)) {
      return reject(new TypeError("Input must be an array"));
    }
//  zakladasz ze zwracane wartosci to liczby z Promise
    const results: number[] = [];
    let completed = 0;

    promises.forEach((promise, index) => {

      Promise.resolve(promise)
        .then((value) => {
          results[index] = value;
          completed++;

          if (completed === promises.length) {
            // zastosowanie typu CustomResult - może być inny 
            const customResult: CustomResult[] = results.map((result: number) => ({ value: result }));
            resolve(customResult);
          }
        })
        .catch((error) => {
          reject(error);
        });
    });

    if (promises.length === 0) {
      resolve([]);
    }
  });
}

const promises = [
  Promise.resolve(10),
  20,
  Promise.resolve(30),
];

myPromiseAll(promises).then((results) => {
  console.log(results);
});