Shipping company investigation
I'd definitely map the tuples to objects, to avoid all the index stuff later on. In this case, the question specifically says it's all about readability, so don't worry about memory usage (also because it's next to nothing).

const orders = data.map(order =&gt; {
  const [orderId, companyName, companyAddress, orderedItem] = order;
  return { orderId, companyName, companyAddress, orderedItem };
});


As for the rest of the code:

Your removeOrder could be implemented using filter, just like the all* functions; no need to manually push to a new array. And your showMostFrequent and itemsCount functions could both be implemented using map - again instead of manually pushing to a new array/object.

Overall though, I'd wrap everything in an Orders object/class, instead of passing the orders array on every call. Maybe something like this:

class Orders {
  constructor(data) {
    this.orders = data.map(order =&gt; {
      const [orderId, companyName, companyAddress, orderedItem] = order;
      return { orderId, companyName, companyAddress, orderedItem };
    });
  }

  // note: Assumes orderIds are unique
  remove(orderId) {
    const index = this.orders.findIndex(order =&gt; order.orderId === orderId);
    if (index === -1) {
      return null;
    } else {
      const order = this.orders[index];
      this.orders.splice(index, 1);
      return order;
    }
  }

  findBy(property, value) {
    return this.orders.filter(order =&gt; order[property] === value);
  }

  findByCompanyName(name) {
    return this.findBy('companyName', name);
  }

  findByCompanyAddress(address) {
    this.findBy('companyAddress', address);
  }

  itemCounts() {
    const grouped = this.orders.reduce((memo, order) =&gt; {
      memo[order.orderedItem] = memo[order.orderedItem] || 0;
      memo[order.orderedItem] += 1;
      return memo;
    }, {})

    return Object
      .keys(grouped)
      .map(key =&gt; { return { orderedItem: key, count: grouped[key] } })
      .sort((a, b) =&gt; a.count - b.count)
      .reverse();
  }
};


I've added a generic findBy method that's used by other two findBy* methods. But more importantly, the remove method now modifies the list of orders, and returns the removed order object (or null), rather than return a new array.