Sorting and update 2D Dimension
You could do better on your time complexity. Your current method runs in O(n^2), where n is the length of the concatenated newArr. However, if you sorted arr1 and arr2 first and then merged them, you could reduce the time complexity to O(n*log(n)), where n is the length of the longer of the two arrays:

function compareInventoryItems(a, b) {
  return (a[1] &lt; b[1] ? -1 : (a[1] &gt; b[1] ? 1 : 0));
}

function updateInventory(arr1, arr2) {
  arr1.sort(compareInventoryItems); // O(n*log(n))
  arr2.sort(compareInventoryItems); // O(m*log(m))

  var newArr = [],
    i1 = 0,
    i2 = 0;

  while (i1 &lt; arr1.length &amp;&amp; i2 &lt; arr2.length) { // O(n+m)

    switch (compareInventoryItems(arr1[i1], arr2[i2])) {
      case -1:
        newArr.push(arr1[i1++]);
        break;
      case 1:
        newArr.push(arr2[i2++]);
        break;
      case 0:
        arr1[i1][0] += arr2[i2][0];
        newArr.push(arr1[i1]);
        i1++;
        i2++;
        break;
    }
  }
  while (i1 &lt; arr1.length) {
    newArr.push(arr1[i1++]);
  }
  while (i2 &lt; arr2.length) {
    newArr.push(arr2[i2++]);
  }

  return newArr;
}

// Overall complexity = O(n*log(n)) + O(m*log(m)) + O(n+m) = O(n*log(n))


One problem is that the passed in arrays are mutated. You have this problem in your current solution too when you add the amounts of a matched item. Another issue is that the new array share pointers to the original inventory items. This could result in someone inadvertently mutating the updated inventory when working with the original arrays passed into updateInventory. If any of that's a concern to your project, then you could create copies of the items to avoid them all:

function updateInventory(arr1, arr2) {
  arr1.map((x) =&gt; x.slice(0)).sort(compareInventoryItems); // O(n*log(n))
  arr2.map((x) =&gt; x.slice(0)).sort(compareInventoryItems); // O(m*log(m))
  // ...