You codes are a little close to the goal, just need to adjust something.

Please see the comment in below demo:

1. When acc.find doesn't find anything, then push one element {name:d.name, data: [value]}

2. if found, then push one {value: ...} into data property.

const arr = [
  {name: "qewregf dqewafs", value: "qewregf dqewafs answer", count: 2},
  {name: "survey with select", value: "survey with select answer", count: 2},
  {name: "werasd", value: "Donald", count: 1},
  {name: "werasd", value: "Jim", count: 1}
];

const result = arr.reduce((acc, d) => {
  const found = acc.find(a => a.name === d.name);
  //const value = { name: d.name, val: d.value };
  const value = { value: d.value, count: d.count }; // the element in data property
  if (!found) {
    //acc.push(...value);
    acc.push({name:d.name, data: [value]}) // not found, so need to add data property
  }
  else {
    //acc.push({ name: d.name, data: [{ value: d.value }, { count: d.count }] });
    found.data.push(value) // if found, that means data property exists, so just push new element to found.data.
  }
  return acc;
}, []);

console.log(result)

I think it's best to think of the problem as 2 different steps:

• First, get all things that belong to the same date together. This is a groupBy that you should be able to look up on StackOverflow or borrow from an existing library.
• Then, you merge each of the date groups in to a single object.

The merge operation is a bit more custom than the groupBy operation. You can implement it in many ways. I would propose to:

• Implement merge to deal with just 2 objects
• Inside merge, loop over all unique keys in those objects and sum them (excluding the date key)
• To apply merge to a date group, use reduce. Note that it's safe to not provide a seed argument here, because you are guaranteed to not have empty groups.

Copy// Merge two date-service entries in to one
const merge = (a, b) => {
  const merged = Object.assign({}, a);
  
  Object.keys(b).forEach(k => {
    if (k !== "date")
      merged[k] = (merged[k] || 0) + b[k];
  });
  
  return merged;
};

const input = [ { date: "3/12/2022", oService: 10},
                { date: "3/13/2022", oService: 12, aService: 1},
                { date: "3/13/2022", oService: 1 }];
          
// Create groups that have a matching date
const byDate = groupByProp("date", input);

// Reduce each group to a single item by merging
const all = Object.values(byDate).map(xs => xs.reduce(merge));

console.log(all);

// A basic `groupBy` implementation
function groupByProp(prop, xs) { 
  return xs.reduce(
    (groups, x) => {
      const k = x[prop];
      if (!groups[k]) groups[k] = [x];
      else groups[k].push(x);
      return groups;
    },
    {}
  );
}

You can use reduce

const data = [{
  name: 'James',
  sex: 'male',
}, {
  name: 'Mike',
  sex: 'male',
}, {
  name: 'Janet',
  sex: 'female',
}, {
  name: 'Mary',
  sex: 'female',
}];

const result = data.reduce((c, v) => {
  c[v.sex] = c[v.sex] || [];       //Initiate if key does not exist
  c[v.sex].push(v);                //Push the value
  return c;
}, {});

console.log(result);

If you want the keys to be plural, you can just append 's'

const result = data.reduce((c, v) => {
  let k = v.sex + 's';
  c[k] = c[k] || [];           //Initiate if key does not exist
  c[k].push(v);                //Push the value
  return c;
}, {});

If you are ok with using lodash, try groupBy

const data = [
  { start: "10-05-2018", assigned_agent: "1257434" },
  { start: "10-05-2018", assigned_agent: "1257434" },
  { start: "10-05-2018", assigned_agent: "1257434" },
  { start: "10-06-2018", assigned_agent: "1257434" },
  { start: "10-05-2018", assigned_agent: "1277852" },
  { start: "10-05-2018", assigned_agent: "1277852" },
]

const group_by_both = _.chain(data)
  .groupBy((el) => `${el.start} ${el.assigned_agent}`)
  .values()
  .value()

console.log(group_by_both)

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

<script src="https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js"></script>

One option would be to reduce the keys():

var o = { 
    a: {value:1}, 
    b: {value:2}, 
    c: {value:3} 
};

Object.keys(o).reduce(function (previous, key) {
    return previous + o[key].value;
}, 0);

With this, you'll want to specify an initial value or the 1st round will be 'a' + 2.

If you want the result as an Object ({ value: ... }), you'll have to initialize and return the object each time:

Object.keys(o).reduce(function (previous, key) {
    previous.value += o[key].value;
    return previous;
}, { value: 0 });