function makeCounter(start = 0, step = 1) {
  let count = start;
  const history = [];

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

const counter = makeCounter(10, 3);
counter.increment().increment().decrement();

console.log(counter.getCount());
console.log(counter.getHistory());

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function processQueue(items) {
  const results = [];

  await items.reduce(async (prevPromise, item) => {
    await prevPromise;
    await delay(0);
    results.push(item * 2);
  }, Promise.resolve());

  return results;
}

processQueue([1, 2, 3, 4])
  .then((data) => console.log("Result:", data))
  .catch((err) => console.log("Error:", err.message));

Promise.resolve()
  .then(() => console.log("Microtask A"))
  .then(() => console.log("Microtask B"));

function highlight(strings, ...values) {
  return strings.reduce((result, str, i) => {
    const value = values[i - 1];
    const formatted =
      typeof value === "number"
        ? `[${value.toFixed(2)}]`
        : `<${String(value).toUpperCase()}>`;
    return result + formatted + str;
  });
}

const item = "sword";
const qty = 3;
const price = 9.5;

const output = highlight`You bought ${qty} ${item}s for $${price} each.`;
console.log(output);

const inventory = [
  { name: "sword", type: "weapon", power: 85 },
  { name: "shield", type: "armor", power: 60 },
  { name: "bow", type: "weapon", power: 72 },
  { name: "helmet", type: "armor", power: 45 },
  { name: "dagger", type: "weapon", power: 91 },
];

const result = inventory
  .filter(item => item.type === "weapon")
  .map(item => ({ ...item, power: item.power * 1.1 }))
  .sort((a, b) => b.power - a.power)
  .reduce((acc, item, index) => {
    acc[index === 0 ? "best" : "rest"] ??= [];
    if (index === 0) acc.best = item.name;
    else acc.rest.push(item.name);
    return acc;
  }, {});

console.log(result.best, result.rest);

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

const store = new Proxy({ xRay: 5, score: 3 }, handler);

store.level = 4;

console.log(store.xRay);
console.log(store.score);
console.log(store.level);
console.log("xRay" in store);
console.log("score" in store);
console.log(store.missing);

const inventory = {
  warehouse: {
    shelves: [
      { id: 'A1', items: ['bolts', 'nuts', 'washers'] },
      { id: 'B2', items: ['hammers', 'wrenches'] },
    ],
    manager: { name: 'Carlos', shift: 'night' },
  },
};

const {
  warehouse: {
    shelves: [{ items: [firstItem, , thirdItem] }, { id: shelfId }],
    manager: { name, shift = 'day' },
  },
} = inventory;

console.log(`${name} | ${shift} | ${shelfId} | ${firstItem} | ${thirdItem}`);

async function fetchData(id) {
  if (id <= 0) throw new Error("Invalid ID");
  return { id, value: id * 10 };
}

async function process() {
  const results = await Promise.allSettled([
    fetchData(1),
    fetchData(-1),
    fetchData(3),
  ]);

  results.forEach(({ status, value, reason }) => {
    if (status === "fulfilled") {
      console.log(`✅ ${value.id}: ${value.value}`);
    } else {
      console.log(`❌ ${reason.message}`);
    }
  });
}

process();