class Counter {
  #count = 0;
  get value() {
    return this.#count;
  }
  set value(v) {
    if (v < this.#count) throw new RangeError('Cannot decrease');
    this.#count = v;
  }
}

const c = new Counter();
c.value = 5;
let msg;
try {
  c.value = 3;
} catch (e) {
  msg = e.message;
}
c.value = 10;
console.log(msg, c.value);

const obj = { b: 1, 2: 'two', a: 3, 1: 'one' };
console.log(Object.keys(obj).join(','), Object.values(obj).join(','));

class Counter {
  static #total = 0;
  #id;
  constructor() {
    Counter.#total++;
    this.#id = Counter.#total;
  }
  get id() { return this.#id; }
  static get total() { return Counter.#total; }
}

class Special extends Counter {
  #label;
  constructor(label) {
    super();
    this.#label = label;
  }
  get label() { return `${this.#label}-${this.id}`; }
}

const c1 = new Counter();
const c2 = new Special('x');
const c3 = new Special('y');
console.log(c1.id, c2.id, c3.label, Counter.total);

const source = {
  count: 0,
  get value() {
    this.count++;
    return this.count;
  }
};

const { value, ...rest } = source;
const spread = { ...source };

console.log(value, spread.value, source.count, JSON.stringify(rest));

const compose = (...fns) => x => fns.reduceRight((acc, fn) => fn(acc), x);
const pipe = (...fns) => x => fns.reduce((acc, fn) => fn(acc), x);
const addOne = x => x + 1;
const double = x => x * 2;
const square = x => x * x;
console.log(compose(square, double, addOne)(3), pipe(square, double, addOne)(3));

let i = 0;
const key = () => `k${i++}`;
const obj = { [key()]: 1, [key()]: 2, [key()]: 3 };
const sym = Symbol('x');
const keyObj = { toString() { return 'dyn'; } };
const obj2 = {
  [sym]: 'secret',
  [`a${1 + 1}`]: 'computed',
  ['a' + 2]: 'overwritten',
  [keyObj]: 'fromObj'
};
console.log(`${Object.keys(obj).join(',')} ${obj2.a2} ${obj2.dyn} ${obj2[sym]}`);

const memoize = (fn) => {
  const cache = new Map();
  return (...args) => {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
};

let calls = 0;
const square = memoize((x) => {
  calls++;
  return x * x;
});

console.log(square(4), square(4), square(-4), calls);

const handler = {
  get(target, prop, receiver) {
    if (!(prop in target)) {
      return `no ${String(prop)}`;
    }
    return Reflect.get(target, prop, receiver);
  },
  set(target, prop, value) {
    if (typeof value === 'number' && value < 0) {
      throw new RangeError('negative');
    }
    return Reflect.set(target, prop, value);
  }
};

const obj = new Proxy({ a: 1, b: 2 }, handler);
obj.c = 10;
console.log(obj.a, obj.c, obj.missing, obj.hasOwnProperty('a'));

let counter = 0;
const state = {
  get value() {
    counter++;
    return counter % 3 === 0 ? null : counter;
  }
};
let result;
result ??= state.value;
result ??= state.value;
result ??= state.value;
result ??= state.value;
console.log(result, counter);