Finding the objects with the cheapest seats
Following the little big O.
You ask

&quot;...if there is a better way following big o notation...&quot; (?)

Big O notation is a formalized mathematical convention used to express how a function (mathematical function) behaves as it approaches infinity.
It is used in computer science to classify an algorithms complexity in regard to a definable input metric, usually the size of the input array when dealing with arrays.
You can not &quot;follow&quot; big O notation as it provides no insight into how to reduce an algorithms complexity apart from a comparison.
Find the big O
To classify your function using Big O, first we need to make it at least readable, and convert it to a function. See snippet.
Now count the number of times the function loops over each item in the input array data. Experience lets you do this in your head, but to demonstrate we modify the function to count every time you handle an item in the input array.
Because we need to fit a curve we need at least 3 different input sizes which I do with some random data.


function bestSeats(data) {
     var c = 0; // the counter
     const seats = data.filter( seat =&gt; 
         (c++,  // count the filter iterations
         seat.price.replace(/[^0-9.-]+/g, "") == Math.min(
                 ...data.map(function ( seat ) { 
                     c += 2;  // this counts as two
                              // once each to map to the arguments of Math.min
                              // once each to find the min                                   
                     return Number(seat.price.replace(/[^0-9.-]+/g, "")) 
                 }
             )
         ))).map(seat =&gt; (
             c++,  // count each result
             seat.seat
         )); 
     return "O(n) = O(" + data.length + ") = " + c;
}

function randomData(size) { 
    const data = [];
    while (size--) { data.push({seat:size, price: "$"+(Math.random() * 100 | 0)})}
    return data;
}
console.log("Eval complexity A:" + bestSeats(randomData(10)));
console.log("Eval complexity B:" + bestSeats(randomData(100)));
console.log("Eval complexity C:" + bestSeats(randomData(500)));



The 3 points we can use to find the curve that best fits
 O(10) ~= 211
 O(100) ~= 20,102
 O(500) ~= 500,005

Experience tells me it's a polynomial of some (not too high) order. Using a graphing calculator I found a reasonable fits at 2.15 making your functions big O complexity
\$O(n^{2.15})\$
Which is insanely inefficient. OMDG!!!!
So keeping

&quot;...in es6 format&quot; (?)

in mind a cleaner more readable, less CO2 producing sea level rising approach is to do a two pass scan of the seats. The first pass finds the min price, the second extracts the min price seat numbers.
This example uses for of loops rather than the Array methods like filter and map, because these array methods have a nasty way of blinding people to the insane level of  complexity of what they do, and for of is a little quicker and often allows better optimizations than the array methods, so it's win win for for of
Examples in \$O(n)\$ linear time.
 function bestSeats(seats) {
     var min = Infinity, minVal;
     const result = [];
     for (const seat of seats) {
         const price = Number(seat.price.slice(1));
         if (price &lt; min) {
             min = price;
             minVal = seat.price;
         }
     }
     for (const seat of seats) {
         if (seat.price === minVal) { result.push(seat.seatNumber) }
     }
     return result;
 }

And if you must use the array methods.
 function bestSeats(seats) {
     const price2Num = seat =&gt; Number(seat.price.slice(1));
     const min = (min, seat) =&gt; price2Num(seat) &lt; min ? price2Num(seat) : min;
     const minPrice = &quot;$&quot; + seats.reduce(min, Infinity);
     return seats.filter(seat =&gt; seat.price === minPrice).map(seat =&gt; seat.seatNumber);
 }