smartobject/ts/index.ts

import * as plugins from './smartobject.plugins';

const fastDeepEqual = plugins.fastDeepEqual;
export {
  fastDeepEqual
};

export interface IObjectCompareResult {
  presentInBothProperties: string[];
  missingProperties: string[];
  additionalProperties: string[];
  nulledProperties: string[];
  undefinedProperties: string[];
  divergingProperties: string[];
  equalProperties: string[];
}

export const compareObjects = (referenceObjectArg: any, comparisonObjectArg: any): IObjectCompareResult => {
  const returnComparisonObject = {
    missingProperties: [],
    additionalProperties: [],
    presentInBothProperties: [],
    nulledProperties: [],
    undefinedProperties: [],
    divergingProperties: [],
    equalProperties: [],
  };
  
  const allProperties = Object.keys(referenceObjectArg).concat(Object.keys(comparisonObjectArg));
  for (const currentProperty of allProperties) {
    // lets find presentInBothProperties
    if (referenceObjectArg[currentProperty] && comparisonObjectArg[currentProperty]) {
      returnComparisonObject.presentInBothProperties.push(currentProperty);
    }

    // lets find missingProperties
    if (referenceObjectArg[currentProperty] && !comparisonObjectArg[currentProperty]) {
      returnComparisonObject.missingProperties.push(currentProperty);
    }

    // lets find additionalProperties
    if (!referenceObjectArg[currentProperty] && comparisonObjectArg[currentProperty]) {
      returnComparisonObject.additionalProperties.push(currentProperty);
    }

    // lets find nulledProperties
    if (comparisonObjectArg[currentProperty] === null) {
      returnComparisonObject.nulledProperties.push(currentProperty);
    }

    // lets find undefinedProperties
    if (comparisonObjectArg[currentProperty] === undefined) {
      returnComparisonObject.undefinedProperties.push(currentProperty);
    }

    // lets find divergingProperties
    if (JSON.stringify(referenceObjectArg[currentProperty]) !== JSON.stringify(comparisonObjectArg[currentProperty])) {
      returnComparisonObject.divergingProperties.push(currentProperty);
    }

    // lets find equalProperties
    if (JSON.stringify(referenceObjectArg[currentProperty]) === JSON.stringify(comparisonObjectArg[currentProperty])) {
      returnComparisonObject.equalProperties.push(currentProperty);
    }
  }

  for (const currentProperty of Object.keys(returnComparisonObject)) {
    const onlyUnique = (value, index, self) => {
      return self.indexOf(value) === index;
    };
    const uniqueArray = returnComparisonObject[currentProperty].filter(onlyUnique);
    returnComparisonObject[currentProperty] = uniqueArray;
  }

  return returnComparisonObject;
};