Replace array values with product of all other values

That takes quadratic time. I'd say the intended/standard way is to compute prefix products and suffix products and for any number, multiply its prefix product with its suffix product. That's linear time. And unlike the divide-the-whole-product-by-the-number approach it doesn't have an issue with zeros or with the whole-array product being too large.

Example:

Input:           [2, 3, 5, 7]
Prefix products: [1, 2, 6, 30] (computed forwards)
Suffix products: [105, 35, 7, 1] (computed backwards)
Result:          [1*105, 2*35, 6*7, 30*1]

The solution you proposed consisted of two nested loops: First loop iterates n time. Inside that, you have a filter and a second loop for all the elements except the currentNum, which is n - 1 time. Therefore time complexity is \$\mathcal{O}(n ( (n - 1)+n )) = \mathcal{O}(n^2)\$

If you want to iterate over all the elements in an array except for one, a better approach can be skipping the loop with continue when index counter is equal to that index.

An alternative solution for this problem can be based on the product of all numbers in the list. "Each element is the product of all the elements except itself", means by dividing each element from the total product you can eliminate the effect of current element in the product. This approach will be \$\mathcal{O}(n + n) = \mathcal{O}(n)\$: one iteration over all elements to get the product and another to calculate the values.

In case you want to return a new array with the results (just as what it states in the function signature), space complexity will be of \$\mathcal{O}(n)\$, but you can modify the same array, therefore \$\mathcal{O}(1)\$.

One special case for this scenario is zero: When the product of all elements in zero, return an array with the same length of input as zero. Note that it will only work for an array of non-zero elements.

This is what it would look like

function nonZeroArrayMultiply(list: number[]): number[] {
    const allProd = list.reduce((prod, cur) => prod * cur)
    let result = []
    for (let n of list)
        result.push(allProd / n)
    return result
}

I haven't written JavaScript in years, so won't attempt a coded response.

If you ran your code and showed us the output, there wouldn't be typos, and it would show that you've actually tested your code.

Your solution unnecessarily creates temporary arrays, when it could simply omit the relevant cell from the calculation. That would speed things up a little.

(Note: I'm not sure your filter would work correctly with repeated values. If I understand it, it would change the results of your second example. Edit: I've checked and I'm fairly confident - your filter discards duplicated values, so your second example doesn't work.)

However, I think we can do this in two passes, provided the numbers are small enough that we won't hit arithmetic overflow (and that's a potential problem with any solution).

If P is the product of all values in ipnArray, then outArray[n] is P/ipnArray[n]. Two simple passes.