const obj = {};
let value = 0;

Object.defineProperty(obj, 'prop', {
  get() {
    return value;
  },
  set(newValue) {
    value = newValue + 1;
  },
  configurable: true,
  enumerable: true
});

obj.prop = 10;
console.log(obj.prop);

function* fibonacci() {
  let [a, b] = [0, 1];
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

function* takeWhile(generator, predicate) {
  for (const value of generator) {
    if (!predicate(value)) break;
    yield value;
  }
}

const fib = fibonacci();
const smallFibs = takeWhile(fib, x => x < 20);
console.log([...smallFibs].join(','));

const x = [1, 2, 3, 4, 5];
console.log(x.slice(1, 3));

const numbers = [1, 2, 3, 4, 5];

const pipeline = (...fns) => (value) => fns.reduce((acc, fn) => fn(acc), value);

const multiply = (x) => (y) => x * y;
const add = (x) => (y) => x + y;
const square = (x) => x * x;

const transform = pipeline(
  multiply(2),
  add(3),
  square
);

const result = numbers.map(transform);
console.log(result);

const target = { name: 'Maya', age: 25 };
const handler = {
  get(obj, prop) {
    if (prop in obj) {
      return obj[prop];
    }
    return `Property '${prop}' not found`;
  },
  set(obj, prop, value) {
    if (typeof value === 'string') {
      obj[prop] = value.toUpperCase();
    } else {
      obj[prop] = value;
    }
    return true;
  }
};
const proxy = new Proxy(target, handler);
proxy.city = 'tokyo';
console.log(proxy.name);
console.log(proxy.city);
console.log(proxy.country);

class EventManager {
  constructor() {
    this.listeners = new Map();
  }
  
  addListener(event, callback) {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, new Set());
    }
    this.listeners.get(event).add(callback);
  }
}

const manager = new EventManager();
const obj = { name: 'Component' };
manager.addListener('click', () => console.log(obj.name));
obj = null;
console.log(manager.listeners.get('click').size);

const obj = {
  name: 'Sarah',
  regularMethod: function() {
    return () => {
      console.log(this.name);
    };
  },
  arrowMethod: () => {
    return () => {
      console.log(this.name);
    };
  }
};

const regular = obj.regularMethod();
const arrow = obj.arrowMethod();
regular();
arrow();

function Vehicle(type) {
  this.type = type;
}

Vehicle.prototype.describe = function() {
  return `This is a ${this.type}`;
};

function Car(brand) {
  Vehicle.call(this, 'car');
  this.brand = brand;
}

Car.prototype = Object.create(Vehicle.prototype);
Car.prototype.constructor = Car;

Car.prototype.describe = function() {
  return Vehicle.prototype.describe.call(this) + ` made by ${this.brand}`;
};

const tesla = new Car('Tesla');
console.log(tesla.describe());
console.log(tesla.constructor.name);

console.log('1');

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

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

queueMicrotask(() => console.log('4'));

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

Promise.resolve().then(() => {
  console.log('6');
  return Promise.resolve();
}).then(() => console.log('7'));

console.log('8');

const Maybe = {
  of: (value) => ({ value, map: f => value == null ? Maybe.nothing() : Maybe.of(f(value)) }),
  nothing: () => ({ value: null, map: () => Maybe.nothing() })
};

const result = Maybe.of(5)
  .map(x => x * 2)
  .map(x => x > 15 ? null : x)
  .map(x => x + 1)
  .map(x => x.toString());

console.log(result.value);

console.log('1');

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

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

queueMicrotask(() => console.log('4'));

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

Promise.resolve().then(() => {
  console.log('6');
  return Promise.resolve();
}).then(() => console.log('7'));

console.log('8');

class EventManager {
  constructor() {
    this.listeners = new Map();
  }
  
  addListener(event, callback) {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, new Set());
    }
    this.listeners.get(event).add(callback);
  }
  
  removeAllListeners() {
    this.listeners.clear();
  }
}

const manager = new EventManager();
const obj = { data: new Array(1000).fill('memory') };
manager.addListener('test', () => obj.data.length);
manager.removeAllListeners();
console.log(manager.listeners.size);

class Counter {
  constructor(max) {
    this.max = max;
  }
  
  *[Symbol.iterator]() {
    let current = 0;
    while (current < this.max) {
      yield current++;
    }
  }
}

const counter = new Counter(3);
const result = [...counter, ...counter];
console.log(result);

const a = { x: 1 };
a.__proto__.x = 2;
const b {};

console.log(a.x, b.x);

class CustomError extends Error {
  constructor(message) {
    super(message);
    this.name = 'CustomError';
  }
}

try {
  try {
    throw new CustomError('inner error');
  } catch (e) {
    console.log(e.name);
    throw new Error('outer error');
  }
} catch (e) {
  console.log(e.message);
  console.log(e instanceof CustomError);
}

const weakSet = new WeakSet();

let obj1 = { id: 1 };
let obj2 = { id: 2 };
let obj3 = obj1;

weakSet.add(obj1);
weakSet.add(obj2);

const results = [
  weakSet.has(obj1),
  weakSet.has(obj3),
  weakSet.has({ id: 2 }),
  weakSet.has(obj2)
];

obj1 = null;

console.log(results);

class DataProcessor {
  constructor(transform) {
    this.transform = transform;
  }
  
  process(data) {
    return this.transform(data);
  }
}

const multiply = x => x * 2;
const addTen = x => x + 10;
const toString = x => `Result: ${x}`;

const compose = (...fns) => x => fns.reduceRight((acc, fn) => fn(acc), x);

const processor = new DataProcessor(compose(toString, addTen, multiply));
console.log(processor.process(5));

const obj = {
  name: 'Sarah',
  getName() { return this.name; },
  getNameArrow: () => this.name
};

const { getName, getNameArrow } = obj;
const boundGetName = obj.getName.bind(obj);

console.log(getName());
console.log(getNameArrow());
console.log(boundGetName());
console.log(obj.getName());
console.log(obj.getNameArrow());

const target = { name: 'Sarah', age: 25 };
const handler = {
  get(obj, prop) {
    if (prop in obj) {
      return obj[prop].toString().toUpperCase();
    }
    return `Property ${prop} not found`;
  },
  set(obj, prop, value) {
    obj[prop] = value * 2;
    return true;
  }
};
const proxy = new Proxy(target, handler);
proxy.salary = 50000;
console.log(proxy.name);
console.log(proxy.age);
console.log(proxy.salary);
console.log(proxy.city);

const obj = { a: 1, b: { c: 2 } };
const frozen = Object.freeze(obj);
frozen.a = 99;
frozen.b.c = 88;
frozen.d = 77;

const sealed = Object.seal({ x: 10, y: 20 });
sealed.x = 30;
sealed.z = 40;
delete sealed.y;

console.log(obj.a, obj.b.c, obj.d);
console.log(sealed.x, sealed.y, sealed.z);