Package Exports

call-tree
call-tree/source/index.js

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (call-tree) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

call-tree

An exploratory library for working objects containing functions.

`concat(object, object)`

Returns an object with all properties from both objects copied. All values will be kept except duplicate functions at the same path.

import { concat } from "call-tree"

concat({ a: () => {}, b: () => {} }, { a: () => {} })
// {
//   a: [
//     () => {},
//     () => {}
//   ],
//   b: () => {}
// }

const fn = () => {}

concat({ a: fn }, { a: fn })
// { a: fn }

`includes(function, object)`

Checks if function exists in object. The value can either be a function or an object with a single leaf node of type function.

import { includes } from "call-tree"

const e = () => {}
const f = () => {}

const tree = {
  a: {
    b: () => {},
  },
  c: {
    d: [{ e }],
  },
}

includes(e, tree) // true
includes({ c: { d: { e } } }) // true
includes(f, tree) // false

`map(callback, object)`

Returns an object with the result of calling the callback with any function found in object.

The callback is called with two arguments: (function, { key, path }).

import { map } from "call-tree"

const tree = {
  a: {
    b: (path) => path,
  },
  c: {
    d: [{ e: (path) => path }],
  },
}

const callback = (fn, { path }) => fn(path)

console.log(map(callback, tree))
// {
//   a: {
//     b: [ "a", "b" ],
//   },
//   c: {
//     d: [
//       {
//         e: [ "c", "d", "e" ],
//       },
//     ],
//   },
// }

`mergeWith(callback, object, object)`

Returns an object with the merged values of the inputs customized by the callback, which is called for every function found in the second object.

The callback is called with two arguments: (value, function). Where value is the value at the corresponding path for the function in the first object.

import { mergeWith } from "call-tree"

const callback = (data, fn) => fn(data)

const tree = {
  timestamp: (ms) => new Date(ms).toISOString(),
  payload: (data) => JSON.stringify(data),
}

console.log(
  mergeWith(
    callback,
    { timestamp: Date.now(), payload: { message: "hello" } },
    tree
  )
)
// {
//   timestamp: '2020-08-03T20:00:42.924Z',
//   payload: '{"message":"hello"}'
// }

`omit(value, object)`

Returns a partial copy of object excluding value. Assuming value has a single leaf node of type function.

import { omit } from "call-tree"

const a = () => {}
const b = () => {}

omit({ x: b }, { x: [a, b] })
// { x: a }