@zitterorg/consequuntur-doloremque-ducimus v6.7.76

Object Resolver

Provides general functionality for dealing with nested properties in JavaScript objects

Available methods:

• isEqual
• filterObject
• removeUndefinedProperties
• hasNestedProperty
• getNestedProperty
• fetchLastNestedProperty
• setNestedProperty
• deleteNestedProperty
• cloneObject
• cloneStructure

Install

Install / Uninstall with npm:

$ npm install @zitterorg/consequuntur-doloremque-ducimus

Uninstall

$ npm uninstall @zitterorg/consequuntur-doloremque-ducimus

Run Tests

$ npm run test

After tests running coverage report can be found in coverage directory

Run ESLint

To perform ESlint check run following command:

$ npm run eslint

To fix issues, found by ESLint run:

$ npm run eslint-fix

Usage

Require package:

// by using require
const resolver = require('@zitterorg/consequuntur-doloremque-ducimus');
// by using import 
//import resolver from "@zitterorg/consequuntur-doloremque-ducimus";
// by using object destructor
//const {cloneObject} = require('dist/object-resolver');

isEqual(obj, propertyPath)

Compares two objects for deep equality

const result = resolver.isEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } });
const result = resolver.isEqual([1, 2, 3], [1, 2, 4]);

filterObject(obj, predicate)

Filters the properties of an object based on a predicate function

const filtered = resolver.filterObject({ a: 1, b: 2, c: 3, d: 4 }, (value, key) => value % 2 === 0);

removeUndefinedProperties(obj)

Removes properties with undefined values from an object

const cleaned = resolver.removeUndefinedProperties({ a: 1, b: undefined, c: { d: 4, e: undefined } });

hasNestedProperty(obj, propertyPath)

Checks if nested property exists, if not return default value

const prop = resolver.hasNestedProperty(obj, 'innerObject.deepObject.value');
const prop = resolver.hasNestedProperty(obj, 'innerObject.deepObject.value', 'defaultValue');

getNestedProperty(objParam, propertyPath, defaultValue)

Get nested property exists and if not empty perform some action

const prop = resolver.getNestedProperty(obj, 'innerObject.deepObject.value')
if (prop) {
  // ...
}

fetchLastNestedProperty(obj, path)

Fetch last chained nested property

const prop = resolver.fetchLastNestedProperty(obj, 'prop');

setNestedProperty(obj, path, value)

Set a deeply nested property in an object

const prop = resolver.setNestedProperty(obj, 'user.profile.name', 'John Doe');

deleteNestedProperty(obj, path)

Delete a deeply nested property in an object

const prop = resolver.deleteNestedProperty(obj, 'user.profile.name', 'John Doe');

cloneObject(obj)

Deep cloning of object

const objCopy = resolver.cloneObject(obj);

cloneStructure(obj, options)

Deep cloning of structure (node > v17)

const structureCopy = resolver.cloneStructure(obj, options);

Examples

const obj1 = { a: 1, b: { c: 2 } };
const obj2 = { a: 1, b: { c: 2 } };
const compareResult = resolver.isEqual(obj1, obj2);

const original = { a: 1, b: 2, c: 3, d: 4 };
const filtered = resolver.filterObject(original, (value, key) => value % 2 === 0);
console.log(filtered); 

const original = { a: 1, b: undefined, c: { d: 4, e: undefined } };
const cleaned = resolver.removeUndefinedProperties(original);

const obj = {
  innerObject: {
    deepObject: {
      value: 'Here I am'
    }
  }
};

console.log(resolver.hasNestedProperty(obj, 'innerObject.deepObject.value'));                         // true
console.log(resolver.hasNestedProperty(obj, 'innerObject.deepObject.wrongValue'));                    // false
console.log(resolver.getNestedProperty(obj, 'innerObject.deepObject.value'));                         // 'Here I am'
console.log(resolver.getNestedProperty(obj, 'innerObject.deepObject.wrongValue'));                    // undefined
console.log(resolver.getNestedProperty(obj, 'innerObject.deepObject.wrongValue.oneMore', 'Oh-h-h'));  // 'Oh-h-h'

const obj = {
  innerObject: {
    deepObject: [
      { name: 'John' },
      { name: 'Nick' },
      { name: 'Ron' }
    ]
  }
};

console.log(resolver.hasNestedProperty(obj, 'innerObject.deepObject.0.name'));              // true
console.log(resolver.getNestedProperty(obj, 'innerObject.deepObject.1.name'));              // 'Nick'

const obj = { role: { role: { role: 'student' } }};
const role = resolver.fetchLastNestedProperty(obj, 'role');

const obj = {'a':{'b':2}, 'c':3};
const objCopy = resolver.cloneObject(obj);

License

MIT