deep-map-object v0.0.5

The utility for deep mapping object keys and values

Why deep-map-object?

The util help facilitating the deep transform from one object to another by given helpers function.

Install:

``shell
npm i deep-map-object
`

Usage:

ES6

`jsx harmony
import deepMap from 'deep-map-object';

const options = function(value) {
return value + 1;
};

const data = {
x: 1,
y: {
z: [2, 3],
t: 4
}
};

const result = deepMap(options)(data);

console.log(result);
/*
{
x: 2,
y: {
z: [3, 4],
t: 5
}
}
*/
`

ES5

`javascript
var deepMap = require('deep-map-object');

var options = function(value) {
return value + 1;
};

var data = {
x: 1,
y: {
z: [2, 3],
t: 4
}
};

var result = deepMap(options)(data);

console.log(result);
/*
{
x: 2,
y: {
z: [3, 4],
t: 5
}
}
*/
`

Api:

$3

+ deepMap(options) will create a resolve function which can transform(resolve) object into another format.
+ the resolve function is the util function that help you to loop deeper into input value.
+ options may be a function that take a primitive value and transform it to target value or may take a object with below format:
`jsx harmony
import deepMap from 'deep-map-object';

const data = { x: 1 };

const result = deepMap(value => value + 1)(data);

console.log(result); // {x : 2}
`

mapValue: function(value: primitive, resolve: function(value: any))
`jsx harmony
import deepMap from 'deep-map-object';

const data = { x: 1 };

const result = deepMap({ mapValue: value => value + 1 })(data);

console.log(result); // {x : 2}
`

mapArray: function(value: array, resolve: function(value: any))
`jsx harmony
import deepMap from 'deep-map-object';

const data = { a: [1, 2, 3] };

const result = deepMap({ mapArray: values => values.map(value => value + 1) })(data);

console.log(result); // { a: [2, 3, 4] };
`

mapObject: function(value: object, resolve: function(value: any))
`jsx harmony
import deepMap from 'deep-map-object';

const data = { a: { num: 0 }, b: { num: 1 } };

const result = deepMap({
mapObject: (obj, resolve) => obj.num > 0
? {...obj, num: obj.num + 1 }
: deepMap.mapObject(obj, resolve)
})(data);

console.log(result); // { a: { num: 0 }, b: { num: 2 } };
`

mapFn: function(value:any, resolve: function(value: any))
// If mapFn is used, mapValue, mapArray, mapObject options will be disabled
`jsx harmony
import deepMap from 'deep-map-object';

const data = { a: { num: 0 }, c: { d: [1, 2] } };

const result = deepMap({
mapFn: (val, resolve) => {
if (Array.isArray(val)) return val.map(resolve);
if (val instanceof Object) return deepMap.mapObject(val, resolve);

return val + 1;
}
})(data);

console.log(result); // { a: { num: 1 }, c: { d: [2, 3] } };
``

+ Based on the type of variable we want to convert, it may be object, array or primitive value.
+ deepMap internally support you to loop deeply in nested object, so you only need to care about transform business

Static functions

deepMap.mapArray: function(value: array, resolve: function(value: any))

+ default mapArray util which run resolve to every array's items

deepMap.mapObject: function(value: object, resolve: function(value: any))

+ default mapObject util which run resolve to every object's key