Utilizing maps would be the perfect solution for that scenario. Here's a practical example of how it could work:

let foodMap = new Map();

foodMap.set('fruit', [{
  name: 'banana',
  type: 'fruit'
}]);
foodMap.set('vegetable', [{
  name: 'carrot',
  type: 'vegetable'
}]);
foodMap.set('meat', [{
  name: 'beef',
  type: 'meat'
}]);

const additionalRecords = [{
  type: 'fruit',
  name: 'orange'
}, {
  type: 'vegetable',
  name: 'broccoli'
}, {
  type: 'meat',
  name: 'turkey'
}]

additionalRecords.forEach(function(record) {
  let array = foodMap.get(record.type);
  array.push(record);
  foodMap.set(record.type, array);
});

for (let [key, value] of foodMap) {
  console.log(key);
  console.log(value);
}

Grouping

In this explanation, we will cover the process of efficiently grouping similar items using a Map in JavaScript. We start by defining two arrays, allRecords and newRecords, without any specific order.

We begin by grouping the items in allRecords based on the type property:

// Grouping allRecords
const allRecords =
  [ { type: 'fruit', name: 'apple' }
  , { type: 'vegetable', name: 'spinach' }
  , { type: 'meat', name: 'chicken' }
  , { type: 'fruit', name: 'raspberry' } // added item
  ]

const groupAll = groupBy(x => x.type, allRecords)

console.log(groupAll)
// Output shown as Map with grouped items

Next, we do the same for the newRecords array:

// Grouping newRecords
const newRecords =
  [ { type: 'meat', name: 'pork' }
  , { type: 'fruit', name: 'pear' }
  , { type: 'vegetable', name: 'celery' }
  , { type: 'dairy', name: 'milk' } // added item
  ]

const groupNew = groupBy(x => x.type, newRecords)

console.log(groupNew)
// Output shown as Map with grouped items

After grouping, we merge these two maps to combine and organize all items together:

// Merging both groups
const mergedGroups = mergeMap(groupAll, groupNew)

console.log(mergedGroups)
// Output shown as Map with combined and organized items

Once all items are organized, we can extract the values and sort them based on different criteria:

// Extracting values for sorting
const unsortedValues = [].concat(...mergedGroups.values())

console.log(unsortedValues)
// Output shown as an array of unsorted values

Sorting

Now, let's delve into sorting these values based on certain parameters. We have defined functions like orderByName and orderByTypes to support custom sorting:

// Sorting by name
const sortedByName = unsortedValues.sort(orderByName)

console.log(sortedByName)
// Output shown as sorted values by name

// Sorting by types
const sortedByType = unsortedValues.sort(orderByTypes("vegetable", "meat", "fruit"))

console.log(sortedByType)
// Output shown as sorted values by type

We can also perform multi-level sorting by combining different sorting criteria:

// Multi-level sorting
const sortedMultiLevel = unsortedValues.sort(mergeComparator(orderByTypes("meat", "fruit", "dairy"), orderByName))

console.log(sortedMultiLevel)
// Output shown as multi-level sorted values

By utilizing these custom sorting functions, we can achieve intricate and flexible sorting behaviors for our data.

Feel free to experiment with the snippet provided to explore different sorting combinations and see the results in your browser console.

Provided that allRecords has already been sorted by type in such a way that all values with the same type are grouped together within the array (or if type is not present at all), then the following function will operate similarly to Object.assign():

function spliceBy<T, K extends keyof T> (key: K, target: T[], ...sources: Iterable<T>[]) {
  const groups: Map<T[K], T[]> = new Map()

  for (const source of sources) {
    for (const entry of source) {
      const value = entry[key]
      const oldEntries = groups.get(value)
      const entries = oldEntries || []

      if (!oldEntries) groups.set(value, entries)

      entries.push(entry)
    }
  }

  for (const [value, entries] of groups) {
    // find the end of a group of entries
    let found = false
    const index = target.findIndex(
      entry => entry[key] === value ? (found = true, false) : found
    )

    if (found) target.splice(index, 0, ...entries)
    else target.push(...entries)
  }

  return target
}

const allRecords = [{type:'fruit',name:'apple'},{type:'vegetable',name:'celery'},{type:'meat',name:'chicken'}]
const newRecords = [{type:'fruit',name:'pear'},{type:'vegetable',name:'spinach'},{type:'meat',name:'pork'}]

console.log(spliceBy('type', allRecords, newRecords))

^{Try it online!}

If you prefer not to modify allRecords, you can use this alternative method:

console.log(spliceBy('type', [], allRecords, newRecords))

Here is a solution that should meet the requirements:

interface Data {
   category: string;
   itemName: string;
}

interface CategorizedData {
   [category: string]: items[];
}

private _dataByCategory: CategorizedData = {};

arrangeAndAdd(allData: Data[], newData: Data[]): Data[] {
   const dataArr: Data[] = [];
   this.add(allData);
   this.add(newData);
   Object.keys(this._dataByCategory).forEach(category => {
      this._dataByCategory[category].forEach(itemName => {
         dataArr.push({category, itemName});
      });
   });

   return dataArr;
}

private add(data: Data[]) {
   data.forEach(entry => {
      if (!this._dataByCategory[entry.category]) {
         this._dataByCategory[entry.category] = [];
      }
      this._dataByCategory[entry.category].push(entry.itemName);
   });
}

Although there may be other approaches with better performance, this solution is presented below:

const allData = [
  {
    category: 'electronics',
    item: 'smartphone'
  },
  {
    category: 'clothing',
    item: 'jacket'
  },
  {
    category: 'food',
    item: 'pizza'
  }
]

const newData = [
  {
    category: 'electronics',
    item: 'laptop'
  },
  {
    category: 'clothing',
    item: 'shoes'
  },
  {
    category: 'food',
    item: 'ice cream'
  }
]

function organizeAndMerge(...data){
    let combinedData = [];
    for(let datum of data){
        combinedData = combinedData.concat(datum);
    }
    combinedData.sort((d1, d2) => {
        if(d1.category == d2.category)
            return 0;
        else if(d1.category > d2.category)
            return 1;
        else
            return -1;
    })
    return combinedData;
}

let mergedData = organizeAndMerge(newData, allData);