ObjectArray.<PathValueObject>ObjectObject*Array.<*>*numberObject
**Kind**: global function
**Returns**: Object - A new object with the path provided equal to data, and optionnaly any values present in baseObject
| Param | Type | Default | Description |
| ------------ | ------------------- | ------------------- | ------------------------------------------------------------- |
| path | string | | The path on which to set a new value |
| data | \* | | The data to set |
| [baseObject] | Object | Object | The base object, serve as the initial accumulator, default {} |
**Example**
```js
//returns { some: { prop: { one: 1, two: 2 } } }
atPathSet('some.prop.one', 1, atPathSet('some.prop.two', 2))
```
## leafs(obj, [previousPath]) ⇒ Array.<PathValueObject>
**Kind**: global function
**Returns**: Array.<PathValueObject> - An array with object containing the leafs information (path/value)
| Param | Type | Default | Description |
| -------------- | ------------------- | ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| obj | object | | The object on which the leafs are selected |
| [previousPath] | array | array | The accumulated path while iterating on obj properties, default to empty array, needed only for recursion, should not be a passed argument when calling the function |
**Example**
```js
// returns [
// { path: ['a', 'b', 'c'], value: 4 },
// { path: ['a', 'b', 'e'], value: 6 },
// { path: ['a', 'd', 'l'], value: 2 }
// ]
leafs({
a: {
b: { c: 4, e: 6 },
d: { l: 2 }
}
})
```
## mapKeys(mappers, objectToMap) ⇒ Object
**Kind**: global function
**Returns**: Object - A new object with the mapped keys
| Param | Type | Description |
| ----------- | ---------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| mappers | Object.<string, function()> | Object with keys corresponding to paths and value corresponding to maping function taking the value at objectToMap path |
| objectToMap | Object | The source object for the mapping |
**Example**
```js
// returns { str: 'SOMEVALUE', num: 4 }
mapKeys(
{ str: x => x.toUpperCase(), num: n => n + 3 },
{ str: 'someValue',
num: 1,
}
)
```
## mapKeysDeep(mappers, objectToMap) ⇒ Object
**Kind**: global function
**Returns**: Object - A new object with the mapped paths
| Param | Type | Description |
| ----------- | ---------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| mappers | Object.<string, function()> | Object with keys corresponding to paths (or simple keys) and value corresponding to maping function taking the value at objectToMap path |
| objectToMap | Object | The source object for the mapping |
**Example**
```js
// returns {
// obj: {
// prop: {
// last: 8
// }
// }
// }
mapKeysDeep(
{
'obj.prop.last': x => x * 2
},
{
obj: {
prop: { last: 4 }
}
}
)
```
## path(path, objToAccess) ⇒ \*
**Kind**: global function
**Returns**: \* - The value corresponding to the path
**Throws**:
- If we try to access a non existing property on objToAccess
| Param | Type | Description |
| ----------- | ------------------- | ------------------------------------------------------------------ |
| path | string | A string representing the path to access (e.g. 'some.prop.nested') |
| objToAccess | Object | The accessed object |
**Example**
```js
// returns 6
path('a.b.c', { a: { b: { c: 6 } } })
```
## pickIndexes(indexes, arrayOfElements) ⇒ Array.<\*>
**Kind**: global function
**Returns**: Array.<\*> - The picked elements in the order of the indexes argument
**Throws**:
- Can throw an error if oyu try to pick an index which does not exist on arrayOfElements
| Param | Type | Description |
| --------------- | --------------------------------- | ---------------------------------------------- |
| indexes | Array.<number> | An array of indexes to pick (the order matter) |
| arrayOfElements | Array.<\*> | The array to pick values from |
**Example**
```js
// returns [6, 6, 2]
pickIndexes([2, 4, 1], [1, 2, 6, 1, 6])
```
## reduceIf(condition, reducer, array, [initAcc]) ⇒ \*
**Kind**: global function
**Returns**: \* - The reduced value
| Param | Type | Default | Description |
| --------- | --------------------- | ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| condition | function | | Take as first argment the current value and next all the reducer argument (acumulator, index, array) and return true if the reducer should be called |
| reducer | function | | Take all the reducer argument (acumulator, value, index, array), return the new accumuulator |
| array | Array | | An array to reduce |
| [initAcc] | \* | Array | The initial accumulator, default empty array |
**Example**
```js
// returns 6
reduceIf(x => x <= 3, (acc, v) => acc + v, [1,2,3,4], 0)
```
## sumOnly(condition, numbers) ⇒ number
**Kind**: global function
**Returns**: number - The sum of matching numbers
| Param | Type | Description |
| --------- | --------------------------------- | -------------------------------------- |
| condition | function | Retun true if the number can be summed |
| numbers | Array.<number> | The array of numbers to sum |
**Example**
```js
// returns 6
sumOnly(x => x <= 3, [1,2,3,4])
```
---
_Source: https://npm.io/package/reduss · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._