convert object of array to object javascript

You could use map and forEach methods.

objArray= { a:[['a','b'],['c','d']],b:[['x','y'],['z','w']]}
Object.keys(objArray).forEach((key) => {
  objArray[key] = objArray[key].map(([id, name]) => ({id, name}));
});

console.log(objArray);

The output can be acheived using a simple for...in loop and using .map() method of arrays:

const input = {
  a: [['a', 'b'], ['c', 'd']],
  b: [['x', 'y'],['z', 'w']]
};

const transform = (input) => {
  const output = {};

  for (key in input) {
    output[key] = input[key].map(([id, name]) => ({id, name}));
  }

  return output;
};

console.log(transform(input));

You can use reduce()

const objArray = { a:[['a','b'],['c','d']],b:[['x','y'],['z','w']]};

const data = Object.keys(objArray).reduce((prev, key) => {
   prev[key] = objArray[key].reduce((res, arr) => {
     res.push({id: arr[0], name: arr[1] });
     return res;
   }, []);
   return prev;
}, {});

console.log(data);

You could build new object with Object.fromEntries.

This approach uses another array for the wanted keys of the objects.

var data = { a: [['a', 'b'],['c','d']],b:[['x','y'],['z','w']]},
    keys = ['id', 'name'],
    result = Object.fromEntries(
        Object
            .entries(data)
            .map(([k, v]) => [
                k,
                v.map(a => Object.fromEntries(keys.map((k, i) => [k, a[i]])))
            ])
    );

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

You can write programs like little stories using prgm -

const myConvert = (o = {}) =>
  prgm                   // given input object, o
    ( o                  // starting with o
    , Object.entries     // get its entries
    , map (convert1)     // then map over them using convert1
    , Object.fromEntries // then make a new object
    )

const convert1 = ([ key, values ]) =>
  prgm                                        // given input key and values
    ( values                                  // starting with values
    , map (([ id, name ]) => ({ id, name }))  // map over arrays creating objs
    , r => [ key, r ]                         // then create a key/result pair
    )

const input =
  { a: [ ['a','b']
       , ['c','d']
       ]
  , b: [ ['x','y']
       , ['z','w']
       ]
  }

console.log
  ( myConvert (input)
  )

// => { ... }

To make this possible, we need -

const prgm = (x, ...fs) =>
  fs .reduce ((r, f) => f (r), x)

const map = f => xs =>
  xs .map (x => f (x))

But perhaps a better name for myConvert is objectMap. To make it generic, we will make the conversion function convert1 a parameter. And since there's no need to modify the keys of the input object, we will only call the conversion function on the object's values -

const identity = x =>
  x

const objectMap = (f = identity) => (o = {}) => 
  prgm                                 // given mapper, f, and object, o
    ( o                                // starting with o
    , Object.entries                   // get its entries
    , map (([ k, v ]) => [ k, f (v) ]) // transform each v using f
    , Object.fromEntries               // then make a new object
    )

Now using generic function objectMap, we can write myConvert as a specialization. This isolates the unique essence of your transformation and detangles it from the rest of your program -

const myConvert =
  objectMap                                  // using generic objectMap
    ( map (([ id, name ]) => ({ id, name })) // convert arrays to objects
    )

const input =
  { a: [ ['a','b']
       , ['c','d']
       ]
  , b: [ ['x','y']
       , ['z','w']
       ]
  }

console.log
  ( myConvert (input)
  )

// => { ... }

Hopefully this shows the power of thinking about your programs from different perspectives. Run the snippet below to confirm the results in your browser -

const prgm = (x, ...fs) =>
  fs .reduce ((r, f) => f (r), x)

const map = f => xs =>
  xs .map (x => f (x))

const identity = x =>
  x

const objectMap = (f = identity) => (o = {}) =>
  prgm
    ( o
    , Object.entries
    , map (([ k, v ]) => [ k, f (v) ])
    , Object.fromEntries
    )

// ---

const myConvert =
  objectMap
    ( map (([ id, name ]) => ({ id, name }))
    )

const input =
  { a: [ ['a','b']
       , ['c','d']
       ]
  , b: [ ['x','y']
       , ['z','w']
       ]
  }

console.log
  ( myConvert (input)
  )