0xD34F

props: {
  user: String
},
emits: ["update:someUser"]

Это неверно. Имя события надо привести в соответствие с именем параметра, исправляем:

- emits: ["update:someUser"]
+ emits: ["update:user"]

- @input="$emit('update:someUser', $event.target.value)"
+ @input="$emit('update:user', $event.target.value)"

function isEqual(a, b) {
  if (a instanceof Object && a.constructor === b?.constructor) {
    const keys = Object.keys(a);
    return (
      keys.length === Object.keys(b).length &&
      keys.every(k => Object.hasOwn(b, k) && isEqual(a[k], b[k]))
    );
  } else {
    return Object.is(a, b);
  }
}

Очевидно, надо написать какой-нибудь другой скрипт.

Объединяем перекрывающиеся интервалы, после объединения суммируем длины:

const sumIntervals = intervals => intervals
  .slice()
  .sort((a, b) => a[0] - b[0])
  .reduce((acc, n) => {
    const top = acc.at(-1);

    if (!top || top[1] < n[0]) {
      acc.push([...n]);
    } else if (top[1] < n[1]) {
      top[1] = n[1];
    }

    return acc;
  }, [])
  .reduce((acc, n) => acc - n[0] + n[1], 0);

Куда и что надо перенести:

const where = '.container';
const what = '.wrapper-item h3';

Переносим:

$(where).prepend(function() {
  return $(what, this);
});

или

document.querySelectorAll(where).forEach(n => {
  n.prepend(n.querySelector(what));
});

Кому и какой надо добавить класс:

const index = 1;
const className = 'active';

Можно при создании элементов проверять, чему равен текущий индекс:

navigation.innerHTML = objectNavigation
  .map((n, i) => `
    <div class="${i === index ? className : ''}">
      <img src="${n.image}">
    </div>`)
  .join('');

или

navigation.append(...objectNavigation.map((n, i) => {
  const div = document.createElement('div');
  const img = document.createElement('img');
  img.src = n.image;
  div.append(img);
  div.classList.toggle(className, i === index);
  return div;
}));

или

for (const [ i, n ] of objectNavigation.entries()) {
  navigation.appendChild(document.createElement('div'));
  navigation.lastChild.appendChild(new Image);
  navigation.lastChild.lastChild.src = n.image;
  navigation.lastChild.className = i === index ? className : '';
}

Другой вариант - добавлять класс после того, как все элементы будут созданы:

navigation.children[index]?.classList.add(className);

data: () => ({
  items: [
    { text:  '69', tooltip:  'hello, world!!' },
    { text: '187', tooltip:  'fuck the world' },
    { text: '666', tooltip: 'fuck everything' },
  ],
}),

<div
  v-for="n in items"
  v-text="n.text"
  :data-tooltip="n.tooltip"
  class="item"
></div>

.item {
  display: inline-flex;
  justify-content: center;
  align-items: center;
  color: white;
  background: red;
  width: 150px;
  height: 50px;
  margin: 10px;
  position: relative;
}
.item:hover::before {
  content: attr(data-tooltip);
  display: inline-block;
  background: blue;
  color: white;
  position: absolute;
}

Сделайте вычисляемое свойство, которое будет представлять данные, соответствующие выбранной категории:

computed: {
  filteredWorks() {
    const category = this.tabs.find(n => n.id === this.activeTabId)?.category;
    return category равна той, что у 'Все работы'
      ? this.works
      : this.works.filter(n => n.category === category);
  },

<div class="articles__items articles__items--works">
  <img v-for="n in filteredWorks" :key="n.id" :src="n.image">
</div>

tabs: [
  { id: '1', name: 'Все работы', category: 'doors' },
  { id: '2', name: 'Окна', category: 'windows' },
  { id: '3', name: 'Двери', category: 'doors' },

Почему у category одинаковые значения (doors)? Надо исправить.

Что, открыть консоль не догадались? Или открыли и тут же закрыли, придя в ужас от количества красного?

$grouped = array_values(array_reduce($arr, function($acc, $n) {
  $acc[$n['api_id']][] = $n;
  return $acc;
}, []));

const newArray = numbers.filter(i => i !== firstMin);

Что, если минимальный элемент представлен в нескольких экземплярах? Вы их все выкинете.

Можно найти индекс минимального элемента и фильтровать по индексу:

function sumTwoSmallestNumbers(nums) {  
  const iMin = nums.indexOf(Math.min(...nums));
  return nums[iMin] + Math.min(...nums.filter((_, i) => i !== iMin));
}

Это если идти вашим путём. Но есть и иные способы решить задачу. Например, можно отсортировать массив и взять два крайних элемента:

const sumTwoSmallestNumbers = ([...nums]) => nums
  .sort((a, b) => b - a)
  .slice(-2)
  .reduce((acc, n) => acc + n, 0);

Или, сосчитать, кто сколько раз повторяется и выбирать второе слагаемое в зависимости от количества повторений первого:

function sumTwoSmallestNumbers(nums) {
  const count = Object.entries(nums.reduce((acc, n) => (acc[n] = -~acc[n], acc), {}));
  return +count[0][0] + +count[+(count[0][1] === 1)][0];
}

Или, пройти по массиву один раз, запоминая встреченные элементы, если они меньше тех, что вам уже попадались (т.е., сделать то, чего от вас тут и ожидается - решить задачу с линейной сложностью по времени и константной по памяти):

function sumTwoSmallestNumbers(nums) {
  let min1 = Infinity;
  let min2 = Infinity;

  for (const n of nums) {
    if (n < min1) {
      [ min1, min2 ] = [ n, min1 ];
    } else if (n < min2) {
      min2 = n;
    }
  }

  return min1 + min2;
}

// или

const sumTwoSmallestNumbers = nums =>
  eval(nums.reduce(([ min1, min2 ], n) => 
    n < min1 ? [    n, min1 ] :
    n < min2 ? [ min1,    n ] :
               [ min1, min2 ]
  , [ Infinity, Infinity ]).join('+'));

Понадобится функция, которая вложенный массив развернёт в плоский:

const flat = (arr, childrenKey = 'children') =>
  (arr instanceof Array ? arr : []).reduce((acc, n) => (
    acc.push(n, ...flat(n[childrenKey], childrenKey)),
    acc
  ), []);

// или, если нужны копии объектов без ссылок на массивы вложенных объектов:
const flat = (arr, childrenKey = 'children') =>
  Array.isArray(arr)
    ? arr.flatMap(({ [childrenKey]: c, ...n }) => [
        n,
        ...flat(c, childrenKey),
      ])
    : [];

Дальше всё просто - вычисляемое свойство, v-for по его значению:

computed: {
  users() {
    return flat(this.elements);
  },
},

<option v-for="n in users" :key="n.id">{{ n.name }}</option>

Promise
  .all(urls.map(url => fetch(url).then(result => result.json())))
  .then(results => results.forEach(result => console.log(result.id)));

<gmap-map
  ref="map"
  ...

const bounds = new google.maps.LatLngBounds();
массивКоординатВашихЛокаций.forEach(n => bounds.extend(n));
this.$refs.map.fitBounds(bounds);

https://codesandbox.io/s/for-https-qna-habr-com-q-...

$grouped = array_values(array_reduce($arr, function($acc, $n) {
  $acc[$n[0]] ??= [ $n[0] ];
  array_push($acc[$n[0]], ...array_slice($n, 1));
  return $acc;
}, []));

Как перемножить элементы массива:

const mul = arr => arr.reduce((acc, n) => acc * n, 1);

Бежим по массиву с количествами элементов, получаем из массива с данными подмассивы указанной длины, перемножаем их содержимое:

const result = count.map(function(n) {
  return mul(data.slice(this[0], this[0] += n));
}, [ 0 ]);

Или, если массив с данными больше не понадобится, можно всегда вырезать у него из начала указанное количество элементов:

const result = count.map(n => mul(data.splice(0, n)));

function combine(a = {}, b = {}, c = {}) {

Читаю текст задачи сверху вниз, снизу вверх, так, сяк, наперекосяк, и никак не могу найти там место, где говорится, что объектов в функцию будет передаваться не больше трёх.

Как обработать заранее неизвестное количество аргументов?

Можно собрать их в массив:

const combine = (...arr) => arr
  .flatMap(Object.entries)
  .reduce((acc, [ k, v ]) => (acc[k] = (acc[k] ?? 0) + v, acc), {});

Или, воспользоваться уже готовым массивоподобным объектом:

function combine() {
  const result = {};

  for (const n of arguments) {
    for (const k in n) {
      if (n.hasOwnProperty(k)) {
        if (!result.hasOwnProperty(k)) {
          result[k] = 0;
        }

        result[k] += n[k];
      }
    }
  }

  return result;
}

const mostFrequentNum = Array
  .from(arr.reduce((acc, n) => acc.set(n, -~acc.get(n)), new Map))
  .reduce((max, n) => max[1] > n[1] ? max : n, [ , 0 ])
  .at(0);

или

const mostFrequentNum = Object
  .entries(arr.reduce((acc, n) => (acc[n] = (acc[n] ?? 0) + 1, acc), {}))
  .reduce((acc, n) => (acc[n[1]] = +n[0], acc), [])
  .pop();

не хочу дублировать код в v-slot:fastFilters, но как мне сделать так, чтоб по определенному флагу на фильтрах он появлялся и в fastFilters

Дублируйте не снаружи, а внутри - то есть, не контент, передаваемый в слот, а сам слот:

<toolbar>
  <slot name="fastFilters">
  <slot name="filters" v-if="а здесь ваш флаг">
</toolbar>
<div class="filters">
  <slot name="filters">
</div>

https://jsfiddle.net/qphgbv8k/