--- Values, variables, and scope ---

// Numbers, strings, booleans, null, undefined, BigInt, Symbol
let n = 42, s = "hi", ok = true, z = null;

// Prefer let/const over var (block vs function scope)
const PI = 3.1416;    // cannot be reassigned
let count = 0;        // can be reassigned

--- Expressions and operators ---

// Math, comparison, logical
1 + 2 * 3;            // 7
10 ** 2;              // 100 (exponent)
a === b;              // strict equality (no coercion)
a && b || c;          // short-circuiting

// Nullish coalescing & optional chaining
const name = user.name ?? "Anonymous";
const city = user.address?.city;  // undefined if any link is missing

--- Control flow ---

if (x > 0) { ... } else { ... }

for (let i = 0; i < 3; i++) { ... }
for (const v of [1,2,3]) { ... }          // iterable loop
while (cond) { ... }

switch (kind) {
  case "cat": doCat(); break;
  default: fallback();
}

--- Function declarations, expressions, lambdas ---

function add(a, b = 0) { return a + b; }   // default param

const mul = function(a, b) { return a * b; }; // expression

const dbl = x => x * 2;                    // arrow (lexical `this`)

--- Objects and arrays ---

const person = { id: 1, name: "Ada" };
const team = ["A", "B", "C"];

// Destructuring
const { name } = person;
const [first, ...rest] = team;

// Shorthand & computed keys
const x = 1, y = 2;
const point = { x, y, ["p" + "3"]: 3 };

// Spread/merge
const withAge = { ...person, age: 36 };
const bigger = [...team, "D"];

--- Template literals ---

const who = "world";
const msg = `Hello, ${who}!
This spans multiple lines.`;

--- Classes (ES2015+) ---

class Counter {
  #n = 0;                     // private field
  inc() { this.#n++; }
  get value() { return this.#n; }
  static from(n) { const c = new Counter(); c.#n = n; return c; }
}

--- Modules ---

// export.js
export const PI = 3.14;
export default function area(r){ return PI * r * r; }

// import.js
import area, { PI } from "./export.js";

--- Promises and async/await ---

// Promise chain
fetch("/api/user")
  .then(r => r.json())
  .then(data => console.log(data))
  .catch(err => console.error(err));

// async/await
async function load() {
  try {
    const r = await fetch("/api/user");
    const data = await r.json();
    console.log(data);
  } catch (e) {
    console.error(e);
  }
}

--- Errors and try/catch ---

try {
  risky();
} catch (err) {
  console.error(err.message);
} finally {
  cleanup();
}

--- DOM basics ---

const btn = document.querySelector("#go");
btn.addEventListener("click", () => {
  document.body.style.backgroundColor = "papayawhip";
});

--- Truthy / falsey & equality ---

// falsey: false, 0, -0, 0n, "", null, undefined, NaN
if ("0") { /* runs: non-empty strings are truthy */ }

// Prefer === to avoid coercion surprises
"5" == 5   // true  (coerces)
"5" === 5  // false (strict)

class Point {
  // public instance fields (per instance, on `this`)
  x = 0;
  y = 0;

  constructor(x, y) {           // runs on `new Point(...)`
    this.x = x; this.y = y;
  }

  // prototype method (shared by instances)
  length() { return Math.hypot(this.x, this.y); }

  // getter/setter
  get r() { return this.length(); }
  set r(v) { const a = Math.atan2(this.y, this.x); this.x = v*Math.cos(a); this.y = v*Math.sin(a); }

  // static method (on the class constructor)
  static origin() { return new Point(0, 0); }
}

class Counter {
  #value = 0;                 // private instance field
  static #MAX = 1_000_000;    // private static field

  get value() { return this.#value; }
  #clamp(n) { return Math.min(n, Counter.#MAX); } // private method

  increment() { this.#value = this.#clamp(this.#value + 1); }

  static from(n) { const c = new Counter(); c.#value = c.#clamp(n); return c; }
}

// Presence check (only inside class that declares #value):
// if (#value in someObj) { ... }

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

class Dog extends Animal {
  constructor(name) { super(name); }          // must call super() before using `this`
  speak() { return `${super.speak()} Woof!`; } // call base method
}

class Config {
  static base = '/api';
  static #token;

  static {                       // runs once when class is evaluated
    this.#token = crypto.randomUUID?.() ?? 'dev-token';
  }

  static authHeader() { return { Authorization: `Bearer ${this.#token}` }; }
}

const Widget = class NamedWidget { /* ... */ }; // name usable inside the class body
class Greeter {
  ['say' + 'Hi']() { return 'hi'; }             // computed method name
  static ['v' + 1] = 2;                         // computed static field
}

class Timer {
  start = performance.now();
  label = `t-${this.start | 0}`;
}

class Base {
  constructor() {
    if (new.target === Base) throw new TypeError('Abstract');
  }
}

class Button {
  // Arrow keeps `this` bound without manual .bind()
  handleClick = (e) => { this.count++; };
  count = 0;
}