tiny-merge-patch/README.md

JSON Merge Patch (RFC 7396) Implementation

Tiny Merge Patch
================

[![codecov](https://img.shields.io/codecov/c/github/QuentinRoy/tiny-merge-patch.svg)](https://codecov.io/gh/QuentinRoy/tiny-merge-patch)
[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org)
[![NPM version](https://img.shields.io/npm/v/tiny-merge-patch.svg)](https://www.npmjs.com/package/tiny-merge-patch)

An implementation of the JSON Merge Patch
[RFC 7396](http://tools.ietf.org/html/rfc7396): a standard format used to
describe modifications to JSON documents. 

This library complies with the functional programming style: it does not mutate
the original target, but recycles what it can. It is particularly appropriate to update a state used by [React](https://reactjs.org), allowing selective re-rendering of the UI.

`tiny-merge-patch` is fully typed and provides strong TypeScript inference for patch results.

`tiny-merge-patch` passes all [RFC 7396](http://tools.ietf.org/html/rfc7396) tests.

## Install

Install the current version (and save it as a dependency):

### npm

```sh
npm install tiny-merge-patch --save
```

### pnpm

```sh
pnpm add tiny-merge-patch
```

## Import

### ES modules

```js
import mergePatch from 'tiny-merge-patch'
```

### ES modules in the browser

```js
import mergePatch from 'https://unpkg.com/tiny-merge-patch/dist/index.mjs'
```

## Usage

```js
// Original document / object.
const doc = {
  a: 'b',
  c: { d: 'e', f: 'g' },
  h: { i: 0 }
};

// JSON merge patch to apply.
const patch = {
  a: 'z',
  c: { f: null } // null marks deletions.
};

// Apply the patch.
const patchedDoc = mergePatch(doc, patch);

// tiny-merge-patch complies with the RFC specification.
assert.deepEqual(patchedDoc, {
  a: 'z',
  c: { d: 'e' },
  h: { i: 0 },
});

// Additionally, it does not mutate the original document...
assert(patchedDoc !== doc);

// ...nor its content...
assert(patchedDoc.c !== doc.c);

// ...but recycles what it can.
assert(patchedDoc.h === doc.h);
```

## Alternatives

- [`json-merge-patch`](https://github.com/pierreinglebert/json-merge-patch) (from which this library is forked)

- [`merge-patch`](https://github.com/krisnye/merge-patch)

- [`json8-merge-patch`](https://github.com/JSON8/merge-patch)

All are in-place.
To avoid mutations of the original object, one can deep-clone beforehand, but it can be expensive.
At the contrary, `tiny-merge-patch` does not alter any of its arguments—but
recycles what it can.
Recycling also allows efficient strict identity-based memoization
(used by [React](https://reactjs.org)'s [PureComponent](https://reactjs.org/docs/react-api.html#reactpurecomponent) for example).

All of the above libraries also embed additional functionalities, such as patch generation from two objects or merge of patches.
`tiny-merge-patch` only focuses on the IETF standard and on patch applications.

(None of the above libraries are particularly big.
Still, `tiny-merge-patch` is smaller if you only need to apply patches.
It is also worth mentioning that unlike
[JSON patches](https://tools.ietf.org/html/rfc6902), there is no way to
implement merge of merge patches that reliably preserves deletion.)

- [`immutable-merge-patch`](https://www.npmjs.com/package/immutable-merge-patch): JSON merge patch implementation for [Immutable.js](https://facebook.github.io/immutable-js/).

# License

[MIT](./LICENSE)

## Development

```sh
pnpm run check
pnpm run build
```

### Releases

```sh
# Create a release note entry
pnpm run changeset

# Apply version bumps from pending changesets
pnpm run version-packages

# Publish to npm
pnpm run release
```

CI and release automation run on GitHub Actions.