chore: check-in

Author: aikoven

.github/workflows/ci.yaml

@@ -0,0 +1,32 @@
+name: ci
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Test and Build
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version:
+          - 12.x
+          - 14.x
+          - 16.x
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: yarn --frozen-lockfile
+      - run: yarn build
+      - run: yarn test

.gitignore

@@ -0,0 +1,5 @@
+node_modules
+lib
+coverage
+.DS_Store
+.vscode

.prettierrc

@@ -0,0 +1,8 @@
+{
+  "singleQuote": true,
+  "bracketSpacing": false,
+  "trailingComma": "all",
+  "proseWrap": "always",
+  "arrowParens": "avoid",
+  "endOfLine": "auto"
+}

LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Deeplay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,141 @@
+# diff-maps [![npm version][npm-image]][npm-url] <!-- omit in toc -->
+
+Calculate diff between two `Map`s
+
+- [Installation](#installation)
+- [Usage](#usage)
+
+## Installation
+
+```
+npm install diff-maps
+```
+
+## Usage
+
+Calculate diff:
+
+```ts
+import {diffMaps} from 'diff-maps';
+
+expect(
+  diffMaps(
+    new Map([
+      ['1', 0],
+      ['2', 0],
+    ]),
+    new Map([
+      ['2', 1],
+      ['3', 1],
+    ]),
+  ),
+).toEqual([
+  {type: 'remove', key: '1', prevValue: 0},
+  {type: 'change', key: '2', value: 1, prevValue: 0},
+  {type: 'add', key: '3', value: 1},
+]);
+```
+
+Use custom equality function (default is
+[`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is)):
+
+```ts
+import {diffMaps} from 'diff-maps';
+import {isEqual} from 'lodash';
+
+expect(
+  diffMaps(
+    new Map([
+      ['1', {data: 0}],
+      ['2', {data: 0}],
+    ]),
+    new Map([
+      ['1', {data: 0}],
+      ['2', {data: 1}],
+    ]),
+    isEqual,
+  ),
+).toEqual([
+  {
+    type: 'change',
+    key: '2',
+    value: {data: 1},
+    prevValue: {data: 0},
+  },
+]);
+```
+
+Apply diff:
+
+```ts
+import {applyDiff} from 'diff-maps';
+
+const state = new Map([
+  ['1', 0],
+  ['2', 0],
+]);
+
+// mutates the map
+applyDiff(state, [
+  {type: 'remove', key: '1', prevValue: 0},
+  {type: 'change', key: '2', value: 1, prevValue: 0},
+  {type: 'add', key: '3', value: 1},
+]);
+
+expect(state).toEqual(
+  new Map([
+    ['2', 1],
+    ['3', 1],
+  ]),
+);
+```
+
+Use with [Immutable.js](https://github.com/immutable-js/immutable-js):
+
+```ts
+import {Map} from 'immutable';
+
+// calculate diff
+
+expect(
+  diffMaps(
+    Map({
+      1: 0,
+      2: 0,
+    }),
+    Map({
+      2: 1,
+      3: 1,
+    }),
+  ),
+).toEqual([
+  {type: 'remove', key: '1', prevValue: 0},
+  {type: 'change', key: '2', value: 1, prevValue: 0},
+  {type: 'add', key: '3', value: 1},
+]);
+
+// apply diff
+
+const state = Map({
+  1: 0,
+  2: 0,
+});
+
+const nextState = state.withMutations(mutableState => {
+  applyDiff(mutableState, [
+    {type: 'remove', key: '1', prevValue: 0},
+    {type: 'change', key: '2', value: 1, prevValue: 0},
+    {type: 'add', key: '3', value: 1},
+  ]);
+});
+
+expect(new Map(nextState)).toEqual(
+  new Map([
+    ['2', 1],
+    ['3', 1],
+  ]),
+);
+```
+
+[npm-image]: https://badge.fury.io/js/diff-maps.svg
+[npm-url]: https://badge.fury.io/js/diff-maps

jest.config.js

@@ -0,0 +1,9 @@
+module.exports = {
+  testPathIgnorePatterns: ['/node_modules/', '/lib/'],
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  collectCoverage: true,
+  coverageDirectory: 'coverage',
+  coverageReporters: ['lcov', 'text'],
+  coveragePathIgnorePatterns: ['/node_modules/', '/lib/'],
+};

package.json

@@ -0,0 +1,38 @@
+{
+  "name": "diff-maps",
+  "version": "0.1.0",
+  "description": "Calculate diff between two Maps",
+  "keywords": [
+    "map",
+    "diff",
+    "changes"
+  ],
+  "repository": "deeplay-io/diff-maps",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/__tests__"
+  ],
+  "scripts": {
+    "clean": "rimraf lib",
+    "test": "jest",
+    "build": "tsc -P tsconfig.build.json",
+    "prepublishOnly": "npm run clean && npm run build && npm test"
+  },
+  "author": "Daniel Lytkin <aikoven@deeplay.io>",
+  "license": "MIT",
+  "devDependencies": {
+    "@tsconfig/recommended": "^1.0.1",
+    "@types/jest": "^26.0.24",
+    "immutable": "^4.0.0-rc.14",
+    "jest": "^27.0.6",
+    "prettier": "^2.3.2",
+    "rimraf": "^2.6.3",
+    "ts-jest": "^27.0.4",
+    "typescript": "~4.3.2"
+  },
+  "dependencies": {}
+}

src/apply.test.ts

@@ -0,0 +1,44 @@
+import {Map as ImmutableMap} from 'immutable';
+import {applyDiff} from './apply';
+
+test('basic', () => {
+  const state = new Map([
+    ['1', 0],
+    ['2', 0],
+  ]);
+
+  applyDiff(state, [
+    {type: 'remove', key: '1', prevValue: 0},
+    {type: 'change', key: '2', value: 1, prevValue: 0},
+    {type: 'add', key: '3', value: 1},
+  ]);
+
+  expect(state).toEqual(
+    new Map([
+      ['2', 1],
+      ['3', 1],
+    ]),
+  );
+});
+
+test('immutable', () => {
+  const state = ImmutableMap({
+    1: 0,
+    2: 0,
+  });
+
+  const nextState = state.withMutations(state => {
+    applyDiff(state, [
+      {type: 'remove', key: '1', prevValue: 0},
+      {type: 'change', key: '2', value: 1, prevValue: 0},
+      {type: 'add', key: '3', value: 1},
+    ]);
+  });
+
+  expect(new Map(nextState)).toEqual(
+    new Map([
+      ['2', 1],
+      ['3', 1],
+    ]),
+  );
+});

src/apply.ts

@@ -0,0 +1,19 @@
+import {DiffItem} from './diff';
+
+export type WriteonlyMap<K, V> = {
+  set(key: K, value: V): unknown;
+  delete(key: K): unknown;
+};
+
+export function applyDiff<Key, Value>(
+  state: WriteonlyMap<Key, Value>,
+  diff: Array<DiffItem<Key, Value>>,
+): void {
+  for (const item of diff) {
+    if (item.type === 'add' || item.type === 'change') {
+      state.set(item.key, item.value);
+    } else if (item.type === 'remove') {
+      state.delete(item.key);
+    }
+  }
+}