const target = { name: 'Sarah', age: 25 };
const handler = {
  get(obj, prop) {
    if (prop === 'toString') {
      return () => `Person: ${obj.name}`;
    }
    return Reflect.get(obj, prop);
  },
  has(obj, prop) {
    return prop !== 'age' && Reflect.has(obj, prop);
  }
};
const proxy = new Proxy(target, handler);
console.log(proxy.name);
console.log('age' in proxy);
console.log(proxy.toString());

async function processData() {
  console.log('Start');
  
  const promise1 = new Promise(resolve => {
    console.log('Promise 1 executor');
    resolve('Result 1');
  });
  
  const promise2 = Promise.resolve('Result 2');
  console.log('After promises created');
  
  const result1 = await promise1;
  console.log(result1);
  
  const result2 = await promise2;
  console.log(result2);
  
  return 'Done';
}

processData().then(result => console.log(result));

console.log('1');

Promise.resolve().then(() => {
  console.log('2');
  Promise.resolve().then(() => console.log('3'));
});

Promise.resolve().then(() => {
  console.log('4');
});

setTimeout(() => console.log('5'), 0);

console.log('6');

function processData() {
  try {
    console.log('processing');
    return 'success';
  } catch (error) {
    console.log('error caught');
    return 'failed';
  } finally {
    console.log('cleanup');
  }
}

const result = processData();
console.log('result:', result);

class EventEmitter {
  constructor() { this.events = {}; }
  on(event, fn) { (this.events[event] ||= []).push(fn); }
  emit(event, data) { this.events[event]?.forEach(fn => fn(data)); }
}

class Logger {
  log(msg) { console.log(`LOG: ${msg}`); }
}

class Counter {
  constructor() { this.count = 0; }
  increment() { this.count++; console.log(this.count); }
}

function withLogging(target) {
  const logger = new Logger();
  return new Proxy(target, {
    get(obj, prop) {
      if (typeof obj[prop] === 'function') {
        return function(...args) {
          logger.log(`calling ${prop}`);
          return obj[prop].apply(obj, args);
        };
      }
      return obj[prop];
    }
  });
}

const emitter = withLogging(new EventEmitter());
const counter = new Counter();
emitter.on('tick', () => counter.increment());
emitter.emit('tick');
emitter.emit('tick');

class Animal {
  constructor(name) {
    this.name = name;
  }
  speak() {
    return `${this.name} makes a sound`;
  }
}

class Dog extends Animal {
  speak() {
    return super.speak() + ' and barks';
  }
}

const pet = new Dog('Rex');
console.log(pet.speak());
console.log(pet instanceof Animal);
console.log(pet.constructor.name);

class DataProcessor {
  constructor(value) {
    this.value = value;
  }
  
  transform(fn) {
    return new DataProcessor(fn(this.value));
  }
  
  getValue() {
    return this.value;
  }
}

const multiply = x => x * 2;
const add = x => x + 10;
const square = x => x * x;

const result = new DataProcessor(5)
  .transform(multiply)
  .transform(add)
  .transform(square)
  .getValue();

console.log(result);

const Flyable = {
  fly() { return 'flying'; }
};

const Swimmable = {
  swim() { return 'swimming'; }
};

function mixin(Base, ...mixins) {
  mixins.forEach(mixin => Object.assign(Base.prototype, mixin));
  return Base;
}

class Bird {}
class Fish {}

const FlyingFish = mixin(class extends Fish {}, Flyable, Swimmable);
const instance = new FlyingFish();
console.log(instance.swim());
console.log(instance.fly());
console.log(instance instanceof Fish);