class Animal {
  #sound;

  constructor(name, sound) {
    this.name = name;
    this.#sound = sound;
  }

  speak() {
    return `${this.name} says ${this.#sound}`;
  }

  static create(name, sound) {
    return new this(name, sound);
  }
}

class Dog extends Animal {
  #tricks = [];

  constructor(name) {
    super(name, "woof");
  }

  learn(trick) {
    this.#tricks.push(trick);
    return this;
  }

  perform() {
    return `${this.name} performs: ${this.#tricks.join(", ")}`;
  }
}

const rex = Dog.create("Rex", "bark");
rex.learn("sit").learn("shake").learn("roll over");

console.log(rex.speak());
console.log(rex.perform());
console.log(rex instanceof Animal);
console.log(rex instanceof Dog);

const user = {
  profile: {
    name: "Marcus",
    score: 0,
    nickname: null,
    bio: undefined,
  },
};

user.profile.nickname ??= "Anonymous";
user.profile.bio ??= "No bio provided";
user.profile.score ??= 100;
user.profile.rank ??= "Beginner";

const { name, score, nickname, bio, rank } = user.profile;
console.log(`${name} | ${score} | ${nickname} | ${bio} | ${rank}`);

const counter = (function () {
  let count = 0;
  const history = [];

  return {
    increment(step = 1) {
      count += step;
      history.push(count);
      return this;
    },
    decrement(step = 1) {
      count -= step;
      history.push(count);
      return this;
    },
    getHistory: () => history,
    getCount: () => count,
  };
})();

counter.increment(5).increment(3).decrement(2);

console.log(counter.getCount(), counter.getHistory().join(" -> "));

const partial = (fn, ...presetArgs) => {
  return function partiallyApplied(...laterArgs) {
    return fn(...presetArgs, ...laterArgs);
  };
};

const calculateTax = (taxRate, discount, price) => {
  const discounted = price - (price * discount) / 100;
  return parseFloat((discounted + (discounted * taxRate) / 100).toFixed(2));
};

const withVAT = partial(calculateTax, 20);
const withVATandDiscount = partial(withVAT, 15);

console.log(withVAT(0, 100));
console.log(withVATandDiscount(200));
console.log(partial(calculateTax, 10, 5)(50));

const values = [0.1 + 0.2, NaN, Infinity, -0, 42.6789];

const results = values.map((v, i) => {
  if (i === 0) return v.toFixed(2);
  if (i === 1) return Number.isFinite(v) + " " + Number.isNaN(v);
  if (i === 2) return Number.isFinite(v) + " " + isFinite(v);
  if (i === 3) return Object.is(v, 0) + " " + Object.is(v, -0);
  if (i === 4) return v.toPrecision(4);
});

console.log(results.join(" | "));

async function* paginate(items, pageSize) {
  for (let i = 0; i < items.length; i += pageSize) {
    const page = items.slice(i, i + pageSize);
    yield await Promise.resolve(page);
  }
}

async function* transform(source, fn) {
  for await (const chunk of source) {
    yield fn(chunk);
  }
}

async function run() {
  const data = [10, 20, 30, 40, 50, 60];

  const pages = paginate(data, 2);
  const mapped = transform(pages, (page) => page.map((x) => x * 2));

  const results = [];
  for await (const page of mapped) {
    results.push(page.reduce((a, b) => a + b, 0));
  }

  console.log(results);
}

run();

class ValidationError extends Error {
  constructor(message, field) {
    super(message);
    this.name = "ValidationError";
    this.field = field;
  }
}

class NetworkError extends ValidationError {
  constructor(message, field, statusCode) {
    super(message, field);
    this.name = "NetworkError";
    this.statusCode = statusCode;
  }
}

const err = new NetworkError("Not Found", "endpoint", 404);

console.log([
  err instanceof NetworkError,
  err instanceof ValidationError,
  err instanceof Error,
  err instanceof TypeError,
].join(", "));