Extract common utils from both adapter files (#952)

* Extract common utils from both adapter files

* Remove unused import

* Use array return for better minification

Author: markerikson

src/entities/sorted_state_adapter.ts

@@ -8,7 +8,11 @@ import {
 } from './models'
 import { createStateOperator } from './state_adapter'
 import { createUnsortedStateAdapter } from './unsorted_state_adapter'
-import { selectIdValue } from './utils'
+import {
+  selectIdValue,
+  ensureEntitiesArray,
+  splitAddedUpdatedEntities
+} from './utils'
 
 export function createSortedStateAdapter<T>(
   selectId: IdSelector<T>,
@@ -25,14 +29,12 @@ export function createSortedStateAdapter<T>(
   }
 
   function addManyMutably(
-    newModels: T[] | Record<EntityId, T>,
+    newEntities: T[] | Record<EntityId, T>,
     state: R
   ): void {
-    if (!Array.isArray(newModels)) {
-      newModels = Object.values(newModels)
-    }
+    newEntities = ensureEntitiesArray(newEntities)
 
-    const models = newModels.filter(
+    const models = newEntities.filter(
       model => !(selectIdValue(model, selectId) in state.entities)
     )
 
@@ -41,14 +43,15 @@ export function createSortedStateAdapter<T>(
     }
   }
 
-  function setAllMutably(models: T[] | Record<EntityId, T>, state: R): void {
-    if (!Array.isArray(models)) {
-      models = Object.values(models)
-    }
+  function setAllMutably(
+    newEntities: T[] | Record<EntityId, T>,
+    state: R
+  ): void {
+    newEntities = ensureEntitiesArray(newEntities)
     state.entities = {}
     state.ids = []
 
-    addManyMutably(models, state)
+    addManyMutably(newEntities, state)
   }
 
   function updateOneMutably(update: Update<T>, state: R): void {
@@ -86,24 +89,14 @@ export function createSortedStateAdapter<T>(
   }
 
   function upsertManyMutably(
-    entities: T[] | Record<EntityId, T>,
+    newEntities: T[] | Record<EntityId, T>,
     state: R
   ): void {
-    if (!Array.isArray(entities)) {
-      entities = Object.values(entities)
-    }
-
-    const added: T[] = []
-    const updated: Update<T>[] = []
-
-    for (const entity of entities) {
-      const id = selectIdValue(entity, selectId)
-      if (id in state.entities) {
-        updated.push({ id, changes: entity })
-      } else {
-        added.push(entity)
-      }
-    }
+    const [added, updated] = splitAddedUpdatedEntities<T>(
+      newEntities,
+      selectId,
+      state
+    )
 
     updateManyMutably(updated, state)
     addManyMutably(added, state)

src/entities/unsorted_state_adapter.ts

@@ -9,7 +9,11 @@ import {
   createStateOperator,
   createSingleArgumentStateOperator
 } from './state_adapter'
-import { selectIdValue } from './utils'
+import {
+  selectIdValue,
+  ensureEntitiesArray,
+  splitAddedUpdatedEntities
+} from './utils'
 
 export function createUnsortedStateAdapter<T>(
   selectId: IdSelector<T>
@@ -27,25 +31,27 @@ export function createUnsortedStateAdapter<T>(
     state.entities[key] = entity
   }
 
-  function addManyMutably(entities: T[] | Record<EntityId, T>, state: R): void {
-    if (!Array.isArray(entities)) {
-      entities = Object.values(entities)
-    }
+  function addManyMutably(
+    newEntities: T[] | Record<EntityId, T>,
+    state: R
+  ): void {
+    newEntities = ensureEntitiesArray(newEntities)
 
-    for (const entity of entities) {
+    for (const entity of newEntities) {
       addOneMutably(entity, state)
     }
   }
 
-  function setAllMutably(entities: T[] | Record<EntityId, T>, state: R): void {
-    if (!Array.isArray(entities)) {
-      entities = Object.values(entities)
-    }
+  function setAllMutably(
+    newEntities: T[] | Record<EntityId, T>,
+    state: R
+  ): void {
+    newEntities = ensureEntitiesArray(newEntities)
 
     state.ids = []
     state.entities = {}
 
-    addManyMutably(entities, state)
+    addManyMutably(newEntities, state)
   }
 
   function removeOneMutably(key: EntityId, state: R): void {
@@ -140,24 +146,14 @@ export function createUnsortedStateAdapter<T>(
   }
 
   function upsertManyMutably(
-    entities: T[] | Record<EntityId, T>,
+    newEntities: T[] | Record<EntityId, T>,
     state: R
   ): void {
-    if (!Array.isArray(entities)) {
-      entities = Object.values(entities)
-    }
-
-    const added: T[] = []
-    const updated: Update<T>[] = []
-
-    for (const entity of entities) {
-      const id = selectIdValue(entity, selectId)
-      if (id in state.entities) {
-        updated.push({ id, changes: entity })
-      } else {
-        added.push(entity)
-      }
-    }
+    const [added, updated] = splitAddedUpdatedEntities<T>(
+      newEntities,
+      selectId,
+      state
+    )
 
     updateManyMutably(updated, state)
     addManyMutably(added, state)

src/entities/utils.ts

@@ -1,4 +1,4 @@
-import { IdSelector } from './models'
+import { EntityState, IdSelector, Update, EntityId } from './models'
 
 export function selectIdValue<T>(entity: T, selectId: IdSelector<T>) {
   const key = selectId(entity)
@@ -16,3 +16,34 @@ export function selectIdValue<T>(entity: T, selectId: IdSelector<T>) {
 
   return key
 }
+
+export function ensureEntitiesArray<T>(
+  entities: T[] | Record<EntityId, T>
+): T[] {
+  if (!Array.isArray(entities)) {
+    entities = Object.values(entities)
+  }
+
+  return entities
+}
+
+export function splitAddedUpdatedEntities<T>(
+  newEntities: T[] | Record<EntityId, T>,
+  selectId: IdSelector<T>,
+  state: EntityState<T>
+): [T[], Update<T>[]] {
+  newEntities = ensureEntitiesArray(newEntities)
+
+  const added: T[] = []
+  const updated: Update<T>[] = []
+
+  for (const entity of newEntities) {
+    const id = selectIdValue(entity, selectId)
+    if (id in state.entities) {
+      updated.push({ id, changes: entity })
+    } else {
+      added.push(entity)
+    }
+  }
+  return [added, updated]
+}

src/serializableStateInvariantMiddleware.ts

@@ -57,7 +57,7 @@ export function findNonSerializableValue(
   const hasIgnoredPaths = ignoredPaths.length > 0
 
   for (const [key, nestedValue] of entries) {
-    const nestedPath = path ? path + '.' + key : key // path.concat(property)
+    const nestedPath = path ? path + '.' + key : key
 
     if (hasIgnoredPaths && ignoredPaths.indexOf(nestedPath) >= 0) {
       continue