const p1 = Promise.resolve(1);
const p2 = Promise.reject('Ошибка');
const p3 = new Promise(res => setTimeout(() => res(42), 100));

allSettled([p1, p2, p3]).then(results => {
  console.log(results);
  /*
  [
    { status: 'fulfilled', value: 1 },
    { status: 'rejected', reason: 'Ошибка' },
    { status: 'fulfilled', value: 42 }
  ]
  */
});

function allSettled(promises) {
  return Promise.all(
    promises.map(p =>
      Promise.resolve(p)
        .then(value => ({ status: 'fulfilled', value }))
        .catch(reason => ({ status: 'rejected', reason }))
    )
  );
}

class Shape {
  constructor(type) {
    this.type = type;
  }

  getArea() {
    if (this.type === 'circle') {
      // Логика для круга
      return Math.PI * 5 * 5;
    } else if (this.type === 'rectangle') {
      // Логика для прямоугольника
      return 10 * 5;
    }
  }

class Shape {
  getArea() {
    throw new Error('Method getArea() must be implemented');
  }
}

class Circle extends Shape {
  constructor(radius) {
    super();
    this.radius = radius;
  }

  getArea() {
    return Math.PI * this.radius * this.radius;
  }
}

class Rectangle extends Shape {
  constructor(width, height) {
    super();
    this.width = width;
    this.height = height;
  }

  getArea() {
    return this.width * this.height;
  }
}

// Теперь можно легко добавить новую фигуру
class Triangle extends Shape {
  constructor(base, height) {
    super();
    this.base = base;
    this.height = height;
  }

  getArea() {
    return 0.5 * this.base * this.height;
  }
}

// Использование
const shapes = [new Circle(5), new Rectangle(10, 5), new Triangle(6, 8)];
shapes.forEach(shape => console.log(shape.getArea()));

 function add(a: number, b: number): number {
  return a + b;
}
add("2", 3); // TS не даст передать строку вместо числа

class Animal {
  move() {
    console.log('Moving');
  }
}

class Dog extends Animal {
  bark() {
    console.log('Woof!');
  }
}

const dog = new Dog();
dog.move(); // Moving
dog.bark(); // Woof!

interface Flyable {
  fly(): void;
}

class Bird implements Flyable {
  fly() {
    console.log('Flying');
  }
}

async function getFastestData() {
  try {
    const api1 = fetch('https://api1.example.com/data');
    const api2 = fetch('https://api2.example.com/data');
    const api3 = fetch('https://api3.example.com/data');

    const winner = await Promise.race([api1, api2, api3]);
    console.log('Самый быстрый API:', await winner.json());
  } catch (error) {
    console.error('Ошибка:', error);
  }
}

function timeout(ms) {
  return new Promise((_, reject) => {
    setTimeout(() => reject(new Error('Время ожидания истекло!')), ms);
  });
}

async function getDataWithTimeout() {
  try {
    const dataPromise = fetch('https://api.example.com/data');
    const result = await Promise.race([dataPromise, timeout(5000)]);
    console.log('Данные:', await result.json());
  } catch (error) {
    console.error('Ошибка:', error.message);
  }
}

getDataWithTimeout();

Объекты базового класса должны быть заменяемыми объектами производного класса без нарушения корректности программы.

class Payment {
  process(amount) {
    return `Обработка платежа на ${amount} рублей`;
  }
}

class CreditCardPayment extends Payment {
  process(amount) {
    return `Оплата ${amount} рублей картой`;
  }
}

class CashPayment extends Payment {
  process(amount) {
    throw new Error("Оплата наличными онлайн не поддерживается!");
  }
}

// Использование
function makePayment(payment, amount) {
  console.log(payment.process(amount));
}

const creditCard = new CreditCardPayment();
const cash = new CashPayment();

makePayment(creditCard, 100); // "Оплата 100 рублей картой"
makePayment(cash, 100);       // Ошибка: Оплата наличными онлайн не поддерживается!

class Payment {
  process(amount) {
    throw new Error("Метод должен быть переопределён");
  }
}

class OnlinePayment extends Payment {
  process(amount) {
    return `Онлайн-оплата на ${amount} рублей`;
  }
}

class CreditCardPayment extends OnlinePayment {
  process(amount) {
    return `Онлайн-оплата картой на ${amount} рублей`;
  }
}

class OfflinePayment extends Payment {
  process(amount) {
    return `Офлайн-оплата на ${amount} рублей`;
  }
}

class CashPayment extends OfflinePayment {
  process(amount) {
    return `Оплата наличными в кассе на ${amount} рублей`;
  }
}

// Использование
function makePayment(payment, amount) {
  console.log(payment.process(amount));
}

const creditCard = new CreditCardPayment();
const cash = new CashPayment();

makePayment(creditCard, 100); // "Онлайн-оплата картой на 100 рублей"
makePayment(cash, 100);       // "Оплата наличными в кассе на 100 рублей"

const arr = [1, [2, 3], [4, [5]]];
console.log(arr.flat()); // [1, 2, 3, 4, [5]]

const arr = [1, [2, 3], [4, [5, [6]]]];
console.log(arr.flat(2)); // [1, 2, 3, 4, 5, [6]]

const arr = [1, [2, [3, [4, [5]]]]];
console.log(arr.flat(Infinity)); // [1, 2, 3, 4, 5]

string.padStart(targetLength, padString)

const num = '42';
console.log(num.padStart(5, '0')); // "00042"

const day = '7';
const month = '3';
console.log(day.padStart(2, '0')); // "07"
console.log(month.padStart(2, '0')); // "03"
// Получаем: "03.07"

interface Device {
  print(doc: string): void;
  scan(doc: string): void;
  fax(doc: string): void;
}

class SimplePrinter implements Device {
  print(doc: string): void {
    console.log(`Печатаю: ${doc}`);
  }
  scan(doc: string): void {
    throw new Error('Не поддерживает сканирование');
  }
  fax(doc: string): void {
    throw new Error('Не поддерживает факс');
  }
}

interface Printable {
  print(doc: string): void;
}
interface Scannable {
  scan(doc: string): void;
}
interface Faxable {
  fax(doc: string): void;
}

class SimplePrinter implements Printable {
  print(doc: string): void {
    console.log(`Печатаю: ${doc}`);
  }
}

const users = [
  { name: "Аня", age: 25, city: "Москва" },
  { name: "Иван", age: 30, city: "Москва" },
  { name: "Оля", age: 22, city: "Казань" },
  { name: "Петя", age: 30, city: "Казань" },
];

const byCity = Object.groupBy(users, user => user.city);
console.log(byCity);
// {
//   "Москва": [ { name: "Аня", age: 25 }, { name: "Иван", age: 30 } ],
//   "Казань": [ { name: "Оля", age: 22 }, { name: "Петя", age: 30 } ]
// }

const byAge = Map.groupBy(users, user => user.age);
console.log(byAge);
// Map(3) {
//   25 => [ { name: "Аня", age: 25 } ],
//   30 => [ { name: "Иван", age: 30 }, { name: "Петя", age: 30 } ],
//   22 => [ { name: "Оля", age: 22 } ]
// }

{condition && <div>Component</div>}

{condition || secondCondition && <div>Component</div>}

{condition || (secondCondition && <div>Component</div>)}

{(condition || secondCondition) && <div>Component</div>}

{condition || secondCondition ? <div>Component</div> : null}

const { promise, resolve, reject } = Promise.withResolvers();

const { promise, resolve, reject } = Promise.withResolvers();

const ws = new WebSocket('wss://example.com');
ws.onmessage = event => resolve(event.data);
ws.onerror = error => reject(error);

promise
.then(data => console.log('Получено:', data))
.catch(error => console.error('Ошибка:', error));

let resolve, reject;
const promise = new Promise((res, rej) => {
  resolve = res;
  reject = rej;
});

function App() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    console.log("Effect:", count);
  }, [count]);

  const handleClick = () => {
    setCount(count + 1);
    setCount(count + 1);
    setCount(count + 1);
  };

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={handleClick}>+3</button>
    </div>
  );
}

function App() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    console.log("Effect:", count);
  }, [count]);

  const handleClick = () => {
    setCount(prev => prev + 1);
    setCount(prev => prev + 1);
    setCount(prev => prev + 1);
  };

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={handleClick}>+3</button>
    </div>
  );
}