SMOB 🧪

A zero dependency library to safe merge objects and arrays with customizable behavior.

Table of Contents

• Installation
• Usage
  • Merger
  • Utils
• License

Installation

1npm install smob --save

Usage

1import { merge } from "smob";
2
3const output = merge(...sources);

The following merge options are set by default:

• array: true Merge object array properties.
• arrayDistinct: false Remove duplicates, when merging array elements.
• arrayPriority: left (options.priority) The source aka leftmost array has by default the highest priority.
• clone: false Deep clone input sources.
• inPlace: false Merge sources in place.
• priority: left The source aka leftmost object has by default the highest priority.

The merge behaviour can be changed by creating a custom merger.

Arguments

• sources (any[] | Record<string, any>)[]: The source arrays/objects.

1import { merge } from 'smob';
2
3merge({ a: 1 }, { b: 2 }, { c: 3 });
4// { a: 1, b: 2, c: 3 }
5
6merge(['foo'], ['bar']);
7// ['foo', 'bar']
8

Merger

A custom merger can simply be created by using the createMerger method.

Array

1import { createMerger } from 'smob';
2
3const merge = createMerger({ array: false });
4
5merge({ a: [1,2,3] }, { a: [4,5,6] });
6// { a: [1,2,3] }

ArrayDistinct

1import { createMerger } from 'smob';
2
3const merge = createMerger({ arrayDistinct: true });
4
5merge({ a: [1,2,3] }, { a: [3,4,5] });
6// { a: [1,2,3,4,5] }

Priority

1import { createMerger } from 'smob';
2
3const merge = createMerger({ priority: 'right' });
4
5merge({ a: 1 }, { a: 2 }, { a: 3 })
6// { a: 3 }

Strategy

1import { createMerger } from 'smob';
2
3const merge = createMerger({
4    strategy: (target, key, value) => {
5        if (
6            typeof target[key] === 'number' &&
7            typeof value === 'number'
8        ) {
9            target[key] += value;
10            return target;
11        }
12    }
13});
14
15merge({ a: 1 }, { a: 2 }, { a: 3 });
16// { a: 6 }

A returned value indicates that the strategy has been applied.

Utils

distinctArray

1import { distinctArray } from 'smob';
2
3distnctArray(['foo', 'bar', 'foo']);
4// ['foo', 'bar']

The function also removes non-primitive elements that are identical by value or reference.

Objects

1import { distinctArray } from 'smob';
2
3distinctArray([{ foo: 'bar' }, { foo: 'bar' }]);
4// [{ foo: 'bar' }]

Arrays

1import { distinctArray } from 'smob';
2
3distinctArray([['foo', 'bar'], ['foo', 'bar']]);
4// [['foo', 'bar']]

isEqual

Checks if two (non-primitive) elements are identical by value or reference.

1import { isEqual } from 'smob';
2
3isEqual({foo: 'bar'}, {foo: 'bar'});
4// true
5
6isEqual(['foo', 'bar'], ['foo', 'bar']);
7// true

License

Made with 💚

Published under MIT License.