Javascript + Filter object of values

Avoid use dictionary when you need Array

I'm not sure why you would prefer to store your Array-like data in a dictionary. I would suggest use a real Array if you need an Array.

Order of Object.keys

You may read more details about the order of Object.keys return values from this post: Does ES6 introduce a well-defined order of enumeration for object properties? The order of Object.keys is defined in ES2020. It may not work as you want in older environments.

Anyway, relay on the order of Object.keys don't seems to be a good idea to me. You may always sort the keys after Object.keys if you want though.

Use Object.assign to convert to / from Array

When you need an Array, use an Array. You can try Object.assign which convert your dictionary into Array and vice versa. (But this only applied to "when you cannot change the interface due to any reason").

function filterData(data, value) {
    const arrayData = Object.assign([], data.map);
    const filteredArrayData = arrayData.filter(list => list.includes(value));
    const result = Object.assign({}, filteredArrayData);
    return result;
}

Review

• the whole filter chain could be on basis of value instead of key from data since there's no real use of key here

filter part

• technically your approach is perfect, just that it could be concise/readable
• you can simplify the filter as in below snippet, simply because readability is one of the TOP priority of a good code IMHO

map part

• instead of juggling the same object inside reduce between all elements we can simply get the required objects out of it.

• one other major thing is that reduce as the name suggests is for when you wish to reduce N elements into exactly 1 element by some logic, which clearly isn't the case here & thus i think map should be preferred.

• we can use map here since at the end we want an array of objects, so here we can return object for each key which at end gets collected as array

• apart from these the redability point again applies here as well, since this can also be simplified very much, refer the snippet to get an idea

• quoting a point from Mozilla's doc on reduce

The reduce() method executes a reducer function (that you provide) on each element of the array, resulting in single output value.

Alternate approach

const  data = {
  "map": {
    "0": ["abcd"],
    "1": ["efgh"],
    "2": ["xyz"],
    "3": ["abcd", "xyz"],
  }
}

const filtered = Object.values(data.map)
  .filter(value => value.includes('xyz'))
   // the () after the "=>" are used to wrap returned result into object
   // the [i] inside ({..}) is used for setting the key dynamically
  .map((value, i) => ({[i]: value}));
  
console.log('filtered', filtered);

• The data structure seems to be object representation of array, so if possible prefer 2D array over object with 0 based keys, this would make things more simple

PS: answer is updated after useful suggestions of @Toby Speight & @Graipher in comments