Object-Scan

Traverse object hierarchies using matching and callbacks.

1. Quickstart

1.1. Install

Using npm:

$ npm i @micromint1npm/deleniti-magnam-magni

In a browser:

<script type="module">
  import objectScan from 'https://cdn.jsdelivr.net/npm/@micromint1npm/deleniti-magnam-magni@<VERSION>/lib/index.min.js';
  // do logic here
</script>

1.2. Usage

import objectScan from '@micromint1npm/deleniti-magnam-magni';

const haystack = { a: { b: { c: 'd' }, e: { f: 'g' } } };
objectScan(['a.*.f'], { joined: true })(haystack);
// => [ 'a.e.f' ]

2. Table of Content

3. Features

• Input traversed at most once during search
• Dependency free and tiny bundle size
• Powerful matching syntax
• Very performant
• Extensive tests and lots of examples

4. Matching

A needle expression specifies one or more paths to an element (or a set of elements) in a JSON structure. Paths use the dot notation.

store.book[0].title

The matching syntax is fully validated and bad input will throw a syntax error. The following syntax is supported:

• Array and Object matching
• Wildcard and Regex matching
• Or Clause
• Arbitrary Depth and Nested Path Recursion
• Exclusion
• Escaping
• Array Needles

4.1. Array

Rectangular brackets for array path matching.

Examples:

const haystack = [0, 1, 2, 3, 4];
objectScan(['[2]'], { joined: true })(haystack);
// => [ '[2]' ]

const haystack = { 0: 'a', 1: 'b', 2: 'c' };
objectScan(['[1]'], { joined: true })(haystack);
// => []

4.2. Object

Property name for object property matching.

Examples:

const haystack = { foo: 0, bar: 1 };
objectScan(['foo'], { joined: true })(haystack);
// => [ 'foo' ]

const haystack = [0, 1, 2, 3, 4];
objectScan(['1'], { joined: true })(haystack);
// => []

4.3. Wildcard

The following characters have special meaning when not escaped:

• *: Match zero or more character
• +: Match one or more character
• ?: Match exactly one character
• \: Escape the subsequent character

Can be used with Array and Object selector.

Examples:

const haystack = { foo: 0, foobar: 1, bar: 2 };
objectScan(['foo*'], { joined: true })(haystack);
// => [ 'foobar', 'foo' ]

const haystack = { a: { b: 0, c: 1 }, d: 2 };
objectScan(['*'], { joined: true })(haystack);
// => [ 'd', 'a' ]

const haystack = [...Array(30).keys()];
objectScan(['[?5]'], { joined: true })(haystack);
// => [ '[25]', '[15]' ]

const haystack = { a: { b: { c: 0 }, d: { f: 0 } } };
objectScan(['a.+.c'], { joined: true })(haystack);
// => [ 'a.b.c' ]

const haystack = { a: { b: { c: 0 }, '+': { c: 0 } } };
objectScan(['a.\\+.c'], { joined: true })(haystack);
// => [ 'a.\\+.c' ]

4.4. Regex

Regex are defined by using parentheses.

Can be used with Array and Object selector.

Examples:

const haystack = { foo: 0, foobar: 1, bar: 2 };
objectScan(['(^foo)'], { joined: true })(haystack);
// => [ 'foobar', 'foo' ]

const haystack = [...Array(20).keys()];
objectScan(['[(5)]'], { joined: true })(haystack);
// => [ '[15]', '[5]' ]

const haystack = ['a', 'b', 'c', 'd'];
objectScan(['[(^[01]$)]'], { joined: true })(haystack);
// => [ '[1]', '[0]' ]

const haystack = ['a', 'b', 'c', 'd'];
objectScan(['[(^[^01]$)]'], { joined: true })(haystack);
// => [ '[3]', '[2]' ]

4.5. Or Clause

Or Clauses are defined by using curley brackets.

Can be used with Array and Object selector and Arbitrary Depth matching.

Examples:

const haystack = ['a', 'b', 'c', 'd'];
objectScan(['[{0,1}]'], { joined: true })(haystack);
// => [ '[1]', '[0]' ]

const haystack = { a: { b: 0, c: 1 }, d: { e: 2, f: 3 } };
objectScan(['{a,d}.{b,f}'], { joined: true })(haystack);
// => [ 'd.f', 'a.b' ]

4.6. Arbitrary Depth

There are two types of arbitrary depth matching:

• **: Matches zero or more nestings
• ++: Matches one or more nestings

Can be combined with Regex and Or Clause by prepending.

Examples:

const haystack = { a: { b: 0, c: 0 } };
objectScan(['a.**'], { joined: true })(haystack);
// => [ 'a.c', 'a.b', 'a' ]

const haystack = { a: { b: 0, c: 0 } };
objectScan(['a.++'], { joined: true })(haystack);
// => [ 'a.c', 'a.b' ]

const haystack = { 1: { 1: ['c', 'd'] }, 510: 'e', foo: { 1: 'f' } };
objectScan(['**(1)'], { joined: true })(haystack);
// => [ '510', '1.1[1]', '1.1', '1' ]

4.7. Nested Path Recursion

To match a nested path recursively, combine Arbitrary Depth matching with an Or Clause.

There are two types of nested path matching:

• **{...}: Matches path(s) in Or Clause zero or more times
• ++{...}: Matches path(s) in Or Clause one or more times

Examples:

const haystack = [[[[0, 1], [1, 2]], [[3, 4], [5, 6]]], [[[7, 8], [9, 10]], [[11, 12], [13, 14]]]];
objectScan(['++{[0][1]}'], { joined: true })(haystack);
// => [ '[0][1][0][1]', '[0][1]' ]

const haystack = [[0, 1, 2], [3, 4, 5], [6, 7, 8]];
objectScan(['++{[0],[1]}'], { joined: true })(haystack);
// => [ '[1][1]', '[1][0]', '[1]', '[0][1]', '[0][0]', '[0]' ]

const haystack = [[[{ a: [1] }], [2]]];
objectScan(['**{[*]}'], { joined: true })(haystack);
// => [ '[0][1][0]', '[0][1]', '[0][0][0]', '[0][0]', '[0]' ]

const haystack = { a: [0, { b: 1 }], c: { d: 2 } };
objectScan(['**{*}'], { joined: true })(haystack);
// => [ 'c.d', 'c', 'a' ]

const haystack = { a: { b: { c: { b: { c: 0 } } } } };
objectScan(['a.**{b.c}'], { joined: true })(haystack);
// => [ 'a.b.c.b.c', 'a.b.c', 'a' ]

const haystack = { a: { b: { c: { b: { c: 0 } } } } };
objectScan(['a.++{b.c}'], { joined: true })(haystack);
// => [ 'a.b.c.b.c', 'a.b.c' ]

4.8. Exclusion

To exclude a path, use exclamation mark.

Examples:

const haystack = { a: 0, b: 1 };
objectScan(['{a,b},!a'], {
  joined: true,
  strict: false
})(haystack);
// => [ 'b' ]

const haystack = { a: 0, b: { a: 1, c: 2 } };
objectScan(['**,!**.a'], { joined: true })(haystack);
// => [ 'b.c', 'b' ]

const haystack = ['a', 'b', 'c', 'd'];
objectScan(['[*]', '[!(^[01]$)]'], { joined: true })(haystack);
// => [ '[3]', '[2]' ]

4.9. Escaping

The following characters are considered special and need to be escaped using \, if they should be matched in a key: [, ], {, }, (, ), ,, ., !, ?, *, + and \.

Examples:

const haystack = { '[1]': 0 };
objectScan(['\\[1\\]'], { joined: true })(haystack);
// => [ '\\[1\\]' ]

4.10. Array Needles

Needles can be passed as arrays, consisting of integers and strings.

When given as arrays, then needles:

• match array keys with integers and object keys with strings
• do not support any other matching syntax
• do not require escaping
• parse faster than regular string needles

This syntax allows for key result of @micromint1npm/deleniti-magnam-magni to be passed back into itself.

Be advised that matchedBy and similar contain the original needles and not copies.

Array needles work similarly to how they work in _.get.

Examples:

const haystack = { a: [{ b: 0 }] };
objectScan([['a', 0, 'b']], { joined: true })(haystack);
// => [ 'a[0].b' ]

const haystack = { 'a.b': [0], a: { b: [1] } };
objectScan([['a.b', 0]], {
  joined: true,
  rtn: 'value'
})(haystack);
// => [ 0 ]

const haystack = { a: [{ b: 0 }, { b: 0 }] };
objectScan([['a', 0, 'b'], ['a', 1, 'b'], 'a[*].b'], {
  joined: true,
  rtn: 'matchedBy'
})(haystack);
// => [ [ [ 'a', 1, 'b' ], 'a[*].b' ], [ [ 'a', 0, 'b' ], 'a[*].b' ] ]

const haystack = { a: [{ b: 0 }, { b: 0 }] };
objectScan([['a', 'b']], {
  joined: true,
  useArraySelector: false
})(haystack);
// => [ 'a[1].b', 'a[0].b' ]

5. Options

Signature of all callbacks is

Fn({ key, value, ... })

where:

• key: key that callback is invoked for (respects joined option).
• value: value for key.
• entry: entry consisting of [key, value].
• property: current parent property.
• gproperty: current grandparent property.
• parent: current parent.
• gparent: current grandparent.
• parents: array of form [parent, grandparent, ...].
• isMatch: true iff last targeting needle exists and is non-excluding.
• matchedBy: all non-excluding needles targeting key.
• excludedBy: all excluding needles targeting key.
• traversedBy: all needles involved in traversing key.
• isCircular: true iff value contained in parents
• isLeaf: true iff value can not be traversed
• depth: length of key
• result: intermittent result as defined by rtn
• getKey(joined?: boolean): function that returns key
• getValue: function that returns value
• getEntry(joined?: boolean): function that returns entry
• getProperty: function that returns property
• getGproperty: function that returns gproperty
• getParent: function that returns parent
• getGparent: function that returns gparent
• getParents: function that returns parents
• getIsMatch: function that returns isMatch
• getMatchedBy: function that returns matchedBy
• getExcludedBy: function that returns excludedBy
• getTraversedBy: function that returns traversedBy
• getIsCircular: function that returns isCircular
• getIsLeaf: function that returns isLeaf
• getDepth: function that returns depth
• getResult: function that returns result
• context: as passed into the search

Notes on Performance

• Arguments backed by getters use Functions Getter and should be accessed via destructuring to prevent redundant computation.
• Getters should be used to improve performance for conditional access. E.g. if (isMatch) { getParents() ... }.
• For performance reasons, the same object is passed to all callbacks.

Search Context

• A context can be passed into a search invocation as a second parameter. It is available in all callbacks and can be used to manage state across a search invocation without having to recompile the search.
• By default, all matched keys are returned from a search invocation. However, when it is not undefined, the context is returned instead.

Examples:

const haystack = { a: { b: { c: 2, d: 11 }, e: 7 } };
objectScan(['**.{c,d,e}'], {
  joined: true,
  filterFn: ({ value, context }) => { context.sum += value; }
})(haystack, { sum: 0 });
// => { sum: 20 }

5.1. filterFn

Type: function Default: undefined

When defined, this callback is invoked for every match. If false is returned, the current key is excluded from the result.

The return value of this callback has no effect when a search context is provided.

Can be used to do processing as matching keys are traversed.

Invoked in same order as matches would appear in result.

For more information on invocation order, please refer to Section Traversal Order.

This method is conceptually similar to Array.filter().

Examples:

const haystack = { a: 0, b: 'bar' };
objectScan(['**'], {
  joined: true,
  filterFn: ({ value }) => typeof value === 'string'
})(haystack);
// => [ 'b' ]

5.2. breakFn

Type: function Default: undefined

When defined, this callback is invoked for every key that is traversed by the search. If true is returned, all keys nested under the current key are skipped in the search and from the final result.

Note that breakFn is invoked before the corresponding filterFn might be invoked.

For more information on invocation order, please refer to Section Traversal Order.

Examples:

const haystack = { a: { b: { c: 0 } } };
objectScan(['**'], {
  joined: true,
  breakFn: ({ key }) => key === 'a.b'
})(haystack);
// => [ 'a.b', 'a' ]

5.3. beforeFn

Type: function Default: undefined

When defined, this function is called before traversal as beforeFn(state = { haystack, context }).

If a value other than undefined is returned from beforeFn, that value is written to state.haystack before traversal.

The content of state can be modified in the function. After beforeFn has executed, the traversal happens using state.haystack and state.context.

The content in state can be accessed in afterFn. Note however that the key result is being overwritten.

Examples:

const haystack = { a: 0 };
objectScan(['**'], {
  joined: true,
  beforeFn: ({ haystack: h, context: c }) => [h, c],
  rtn: 'key'
})(haystack, { b: 0 });
// => [ '[1].b', '[1]', '[0].a', '[0]' ]

const haystack = { a: 0, b: 1 };
objectScan(['**'], {
  joined: true,
  beforeFn: ({ haystack: h }) => Object.keys(h),
  rtn: ['key', 'value']
})(haystack);
// => [ [ '[1]', 'b' ], [ '[0]', 'a' ] ]

5.4. afterFn

Type: function Default: undefined

When defined, this function is called after traversal as afterFn(state = { result, haystack, context }).

Additional information written to state in beforeFn is available in afterFn.

The content of state can be modified in the function. In particular the key state.result can be updated.

If a value other than undefined is returned from afterFn, that value is written to state.result.

After beforeFn has executed, the key state.result is returned as the final result.

Examples:

const haystack = { a: 0 };
objectScan(['**'], {
  afterFn: ({ result, context }) => result + context,
  rtn: 'count'
})(haystack, 5);
// => 6

const haystack = { a: 0, b: 3, c: 4 };
objectScan(['**'], {
  afterFn: ({ result }) => result.filter((v) => v > 3),
  rtn: 'value'
})(haystack);
// => [ 4 ]

const haystack = {};
objectScan(['**'], {
  beforeFn: (state) => { /* eslint-disable no-param-reassign */ state.custom = 7; },
  afterFn: (state) => state.custom
})(haystack);
// => 7

5.5. compareFn

Type: function Default: undefined

This function has the same signature as the callback functions. When defined it is expected to return a function or undefined.

The returned value is used as a comparator to determine the traversal order of any object keys.

This works together with the reverse option.

Please refer to Section Traversal Order for more information.

Examples:

const haystack = { a: 0, c: 1, b: 2 };
objectScan(['**'], {
  joined: true,
  compareFn: () => (k1, k2) => k1.localeCompare(k2),
  reverse: false
})(haystack);
// => [ 'a', 'b', 'c' ]

5.6. reverse

Type: boolean Default: true

When set to true, the traversal is performed in reverse order. This means breakFn is executed in reverse post-order and filterFn in reverse pre-order. Otherwise breakFn is executed in pre-order and filterFn in post-order.

When reverse is true the traversal is delete-safe. I.e. property can be deleted / spliced from parent object / array in filterFn.

Please refer to Section Traversal Order for more information.

Examples:

const haystack = { f: { b: { a: {}, d: { c: {}, e: {} } }, g: { i: { h: {} } } } };
objectScan(['**'], {
  breakFn: ({ isMatch, property, context }) => { if (isMatch) { context.push(property); } },
  reverse: true
})(haystack, []);
// => [ 'f', 'g', 'i', 'h', 'b', 'd', 'e', 'c', 'a' ]

const haystack = { f: { b: { a: {}, d: { c: {}, e: {} } }, g: { i: { h: {} } } } };
objectScan(['**'], {
  filterFn: ({ property, context }) => { context.push(property); },
  reverse: true
})(haystack, []);
// => [ 'h', 'i', 'g', 'e', 'c', 'd', 'a', 'b', 'f' ]

const haystack = { f: { b: { a: {}, d: { c: {}, e: {} } }, g: { i: { h: {} } } } };
objectScan(['**'], {
  breakFn: ({ isMatch, property, context }) => { if (isMatch) { context.push(property); } },
  reverse: false
})(haystack, []);
// => [ 'f', 'b', 'a', 'd', 'c', 'e', 'g', 'i', 'h' ]

const haystack = { f: { b: { a: {}, d: { c: {}, e: {} } }, g: { i: { h: {} } } } };
objectScan(['**'], {
  filterFn: ({ property, context }) => { context.push(property); },
  reverse: false
})(haystack, []);
// => [ 'a', 'c', 'e', 'd', 'b', 'h', 'i', 'g', 'f' ]

5.7. orderByNeedles

Type: boolean Default: false

When set to false, all targeted keys are traversed and matched in the order determined by the compareFn and reverse option.

When set to true, all targeted keys are traversed and matched in the order determined by the corresponding needles, falling back to the above ordering.

Note that this option is constraint by the depth-first search approach.

Examples:

const haystack = { a: 0, b: 1, c: 1 };
objectScan(['c', 'a', 'b'], {
  joined: true,
  orderByNeedles: true
})(haystack);
// => [ 'c', 'a', 'b' ]

const haystack = { a: 0, b: 1, c: 1 };
objectScan(['b', '*'], {
  joined: true,
  reverse: true,
  orderByNeedles: true
})(haystack);
// => [ 'b', 'c', 'a' ]

const haystack = { a: 0, b: 1, c: 1 };
objectScan(['b', '*'], {
  joined: true,
  reverse: false,
  orderByNeedles: true
})(haystack);
// => [ 'b', 'a', 'c' ]

const haystack = { a: 0, b: { c: 1 }, d: 2 };
objectScan(['a', 'b.c', 'd'], {
  joined: true,
  orderByNeedles: true
})(haystack);
// => [ 'a', 'b.c', 'd' ]

const haystack = { a: 0, b: { c: 1 }, d: 2 };
objectScan(['b', 'a', 'b.c', 'd'], {
  joined: true,
  orderByNeedles: true
})(haystack);
// => [ 'b.c', 'b', 'a', 'd' ]

5.8. abort

Type: boolean Default: false

When set to true the traversal immediately returns after the first match.

Examples:

const haystack = { a: 0, b: 1 };
objectScan(['a', 'b'], {
  rtn: 'property',
  abort: true
})(haystack);
// => 'b'

const haystack = ['a', 'b'];
objectScan(['[0]', '[1]'], {
  rtn: 'count',
  abort: true
})(haystack);
// => 1

5.9. rtn

Type: string or array or function Default: dynamic

Defaults to key when search context is undefined and to context otherwise.

Can be explicitly set as a string:

• context: search context is returned
• key: as passed into filterFn
• value: as passed into filterFn
• entry: as passed into filterFn
• property: as passed into filterFn
• gproperty: as passed into filterFn
• parent: as passed into filterFn
• gparent: as passed into filterFn
• parents: as passed into filterFn
• isMatch: as passed into filterFn
• matchedBy: as passed into filterFn
• excludedBy: as passed into filterFn
• traversedBy: as passed into filterFn
• isCircular: as passed into filterFn
• isLeaf: as passed into filterFn
• depth: as passed into filterFn
• bool: returns true iff a match is found
• count: returns the match count
• sum: returns the match sum

When set to array, can contain any of the above except context, bool, count and sum.

When set to function, called with callback signature for every match. Returned value is added to the result.

When abort is set to true and rtn is not context, bool, count or sum, the first entry of the result or undefined is returned.

Examples:

const haystack = ['a', 'b', 'c'];
objectScan(['[*]'], { rtn: 'value' })(haystack);
// => [ 'c', 'b', 'a' ]

const haystack = { foo: ['bar'] };
objectScan(['foo[*]'], { rtn: 'entry' })(haystack);
// => [ [ [ 'foo', 0 ], 'bar' ] ]

const haystack = { a: { b: { c: 0 } } };
objectScan(['a.b.c', 'a'], { rtn: 'property' })(haystack);
// => [ 'c', 'a' ]

const haystack = { a: { b: 0, c: 1 } };
objectScan(['a.b', 'a.c'], { rtn: 'bool' })(haystack);
// => true

const haystack = { a: 0 };
objectScan(['**'], { rtn: 'context' })(haystack);
// => undefined

const haystack = { a: { b: { c: 0, d: 1 } } };
objectScan(['a.b.{c,d}'], { rtn: 'key' })(haystack, []);
// => [ [ 'a', 'b', 'd' ], [ 'a', 'b', 'c' ] ]

const haystack = { a: { b: { c: 0, d: 1 } } };
objectScan(['a.b.{c,d}'], { rtn: ['property', 'value'] })(haystack, []);
// => [ [ 'd', 1 ], [ 'c', 0 ] ]

const haystack = { a: { b: { c: 0, d: 1 } } };
objectScan(['**'], {
  filterFn: ({ isLeaf }) => isLeaf,
  rtn: ({ value }) => value + 1
})(haystack);
// => [ 2, 1 ]

const haystack = { a: { b: { c: -2, d: 1 }, e: [3, 7] } };
objectScan(['**'], {
  filterFn: ({ value }) => typeof value === 'number',
  rtn: 'sum'
})(haystack);
// => 9

5.10. joined

Type: boolean Default: false

Keys are returned as a string when set to true instead of as a list.

Setting this option to true will negatively impact performance.

This setting can be overwritten by using the getter method getKey() or getEntry().

Note that _.get and _.set fully support lists.

Examples:

const haystack = [0, 1, { foo: 'bar' }];
objectScan(['[*]', '[*].foo'], { joined: true })(haystack);
// => [ '[2].foo', '[2]', '[1]', '[0]' ]

const haystack = [0, 1, { foo: 'bar' }];
objectScan(['[*]', '[*].foo'])(haystack);
// => [ [ 2, 'foo' ], [ 2 ], [ 1 ], [ 0 ] ]

const haystack = { a: { b: { c: 0 } } };
objectScan(['**.c'], {
  joined: true,
  rtn: ({ getKey }) => [getKey(true), getKey(false), getKey()]
})(haystack);
// => [ [ 'a.b.c', [ 'a', 'b', 'c' ], 'a.b.c' ] ]

const haystack = { a: { b: { c: 0 } } };
objectScan(['**.c'], { rtn: ({ getEntry }) => [getEntry(true), getEntry(false), getEntry()] })(haystack);
// => [ [ [ 'a.b.c', 0 ], [ [ 'a', 'b', 'c' ], 0 ], [ [ 'a', 'b', 'c' ], 0 ] ] ]

5.11. useArraySelector

Type: boolean Default: true

When set to false, no array selectors should be used in any needles and arrays are automatically traversed.

Note that the results still include the array selectors.

Examples:

const haystack = [{ a: 0 }, { b: [{ c: 1 }, { d: 2 }] }];
objectScan(['a', 'b.d'], {
  joined: true,
  useArraySelector: false
})(haystack);
// => [ '[1].b[1].d', '[0].a' ]

const haystack = [{ a: 0 }, { b: 1 }];
objectScan([''], {
  joined: true,
  useArraySelector: false
})(haystack);
// => [ '[1]', '[0]' ]

5.12. strict

Type: boolean Default: true

When set to true, errors are thrown when:

• a path is identical to a previous path
• a path invalidates a previous path
• a path contains consecutive recursions

Examples:

const haystack = [];
objectScan(['a.b', 'a.b'], { joined: true })(haystack);
// => 'Error: Redundant Needle Target: "a.b" vs "a.b"'

const haystack = [];
objectScan(['a.{b,b}'], { joined: true })(haystack);
// => 'Error: Redundant Needle Target: "a.{b,b}" vs "a.{b,b}"'

const haystack = [];
objectScan(['a.b', 'a.**'], { joined: true })(haystack);
// => 'Error: Needle Target Invalidated: "a.b" by "a.**"'

const haystack = [];
objectScan(['**.!**'], { joined: true })(haystack);
// => 'Error: Redundant Recursion: "**.!**"'

6. Competitors

This library has a similar syntax and can perform similar tasks to jsonpath or jmespath. But instead of querying an object hierarchy, it focuses on traversing it. Hence, it is designed around handling multiple paths in a single traversal. No other library doing this is currently available.

While nimma provides the ability to traverse multiple paths, it doesn't do it in a single traversal.

A one-to-one comparison with other libraries is difficult due to difference in functionality, but it can be said that @micromint1npm/deleniti-magnam-magni is more versatile at similar performance.

| |objectScan (compiled)|objectScan|nimma (compiled)|nimma|jsonpath-plus|jsonpath|jmespath| |---|---|---|---|---|---|---|---| |Get Key|||||||-| |Get Value|||||||| |Conditional Path| [1]| [1]|||||| |Recursive Traversal| [2]| [2]| [3]| [3]|![](https://img.shields.io/badge/2.63x-6c961c?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAMAAABEpIrGAAAAAXNSR0IArs4c6QAAAN5QTFRFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA