class Pipeline {
  #value;
  #log = [];

  constructor(value) {
    this.#value = value;
  }

  map(fn) {
    this.#value = fn(this.#value);
    this.#log.push(`map:${this.#value}`);
    return this;
  }

  filter(fn) {
    if (Array.isArray(this.#value)) {
      this.#value = this.#value.filter(fn);
      this.#log.push(`filter:${this.#value}`);
    }
    return this;
  }

  reduce(fn, init) {
    if (Array.isArray(this.#value)) {
      this.#value = this.#value.reduce(fn, init);
      this.#log.push(`reduce:${this.#value}`);
    }
    return this;
  }

  result() {
    console.log(this.#log.join(' | '));
    return this.#value;
  }
}

new Pipeline([1, 2, 3, 4, 5, 6])
  .filter(n => n % 2 === 0)
  .map(arr => arr.map(n => n ** 2))
  .reduce((acc, n) => acc + n, 0)
  .result();

const name = "Taylor";
const age = 28;
const role = "engineer";

const user = {
  name,
  age,
  role,
  greet() {
    return `Hi, I'm ${this.name}, age ${this.age}`;
  },
  get info() {
    return `${this.role.toUpperCase()} @ ${this.age}`;
  }
};

const { name: userName, info, greet } = user;

console.log(userName);
console.log(info);
console.log(greet.call({ name: "Jordan", age: 35 }));

const handler = {
  get(target, prop, receiver) {
    if (prop in target) {
      const value = Reflect.get(target, prop, receiver);
      return typeof value === "number" ? value * 2 : value;
    }
    return `Property "${prop}" not found`;
  },
  set(target, prop, value) {
    if (typeof value !== "number") {
      throw new TypeError("Only numbers allowed");
    }
    Reflect.set(target, prop, value ** 2);
    return true;
  },
  has(target, prop) {
    return prop.startsWith("_") ? false : prop in target;
  },
};

const store = new Proxy({ _secret: 99, score: 5 }, handler);

store.level = 3;

console.log(store.score);
console.log(store.level);
console.log("_secret" in store);
console.log("score" in store);
console.log(store._secret);

class Range {
  constructor(start, end, step = 1) {
    this.start = start;
    this.end = end;
    this.step = step;
  }

  [Symbol.iterator]() {
    let current = this.start;
    const { end, step } = this;
    return {
      next() {
        if (current <= end) {
          const value = current;
          current += step;
          return { value, done: false };
        }
        return { value: undefined, done: true };
      }
    };
  }
}

const range = new Range(1, 10, 3);
const result = [...range].map(n => n ** 2);
console.log(result);

const p1 = new Promise((resolve) => {
  console.log("A");
  resolve("B");
});

const p2 = p1.then((val) => {
  console.log(val);
  return "C";
});

p2.then((val) => console.log(val));

console.log("D");