immutable-object-methods - npm Package Compare versions

Comparing version 1.0.3 to 1.1.0

dist/index.js

@@ -6,44 +6,37 @@ 'use strict';
 });
-exports.setIn = undefined;
+exports.without = exports.set = exports.getIn = exports.setIn = exports.mergeDeep = exports.assign = undefined;
 
-var _objectAssign = require('object-assign');
+var _assign2 = require('./assign');
 
-var _objectAssign2 = _interopRequireDefault(_objectAssign);
+var _assign3 = _interopRequireDefault(_assign2);
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _mergeDeep2 = require('./merge-deep');
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var _mergeDeep3 = _interopRequireDefault(_mergeDeep2);
 
-function _toArray(arr) { return Array.isArray(arr) ? arr : Array.from(arr); }
+var _setIn2 = require('./set-in');
 
-var changesInput = function changesInput(input, keys, value) {
-  for (var i = 0; i < keys.length; ++i) {
-    if (!input) {
-      return true;
-    }
+var _setIn3 = _interopRequireDefault(_setIn2);
 
-    input = input[keys[i]];
-  }
+var _getIn2 = require('./get-in');
 
-  return input !== value;
-};
+var _getIn3 = _interopRequireDefault(_getIn2);
 
-var _setIn = function _setIn() {
-  var input = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
-  var _ref = arguments[1];
+var _set2 = require('./set');
 
-  var _ref2 = _toArray(_ref);
+var _set3 = _interopRequireDefault(_set2);
 
-  var key = _ref2[0];
+var _without2 = require('./without');
 
-  var rest = _ref2.slice(1);
+var _without3 = _interopRequireDefault(_without2);
 
-  var value = arguments[2];
-  return (0, _objectAssign2.default)({}, input, _defineProperty({}, key, rest.length ? _setIn(input[key], rest, value) : value));
-};
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var setIn = exports.setIn = function setIn(input, keys, value) {
-  return changesInput(input, keys, value) ? _setIn(input, keys, value) : input;
-};
+var assign = exports.assign = _assign3.default;
+var mergeDeep = exports.mergeDeep = _mergeDeep3.default;
+var setIn = exports.setIn = _setIn3.default;
+var getIn = exports.getIn = _getIn3.default;
+var set = exports.set = _set3.default;
+var without = exports.without = _without3.default;
 
-exports.default = { setIn: setIn };
+exports.default = { assign: assign, getIn: getIn, setIn: setIn, mergeDeep: mergeDeep, set: set, without: without };

example.js

@@ -1,2 +0,2 @@
-import {setIn} from 'immutable-object-methods';
+import {getIn, setIn, mergeDeep, assign, set, without} from 'immutable-object-methods';
 
@@ -8,1 +8,25 @@ const input = {a: {b: 'c'}};
 console.log(updated);
+
+const merged = mergeDeep(
+  {foo: 'bar'},
+  {beep: {boop: 4711}, foo: 'bas'}
+);
+console.log(merged);
+
+// immutable assign
+const assigned = assign({foo: 'bar'}, {foz: 'baz'});
+console.log(assigned);
+
+const value = getIn({a: {b: 'c'}}, ['a', 'b']);
+// will print out 'c'
+console.log(value);
+
+const noneExists = getIn({}, ['a', 'b']);
+// don't throw if value doesn't exists, just return undefined
+console.log(noneExists === undefined);
+
+const data = set({beep: 'boop'}, 'foo', 'bar');
+console.log(data);
+
+const beep = without({foo: 'bar'}, 'foo');
+console.log(beep);

lib/index.js

@@ -1,24 +0,15 @@
-import assign from 'object-assign';
+import _assign from './assign';
+import _mergeDeep from './merge-deep';
+import _setIn from './set-in';
+import _getIn from './get-in';
+import _set from './set';
+import _without from './without';
 
-const changesInput = (input, keys, value) => {
-  for (let i = 0; i < keys.length; ++i) {
-    if (!input) {
-      return true;
-    }
+export const assign = _assign;
+export const mergeDeep = _mergeDeep;
+export const setIn = _setIn;
+export const getIn = _getIn;
+export const set = _set;
+export const without = _without;
 
-    input = input[keys[i]];
-  }
-
-  return input !== value;
-};
-
-const _setIn = (input = {}, [key, ...rest], value) => assign(
-  {}, input, {
-    [key]: rest.length ? _setIn(input[key], rest, value) : value
-  }
-);
-
-export const setIn = (input, keys, value) =>
-  changesInput(input, keys, value) ? _setIn(input, keys, value) : input;
-
-export default {setIn};
+export default {assign, getIn, setIn, mergeDeep, set, without};

package.json

 {
   "name": "immutable-object-methods",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "Update normal plain javascript object, immutable style. Simlar to how immutable.js, seamless-immutable etc does it but a lot smaller and simpler.",
@@ -11,3 +11,3 @@ "main": "dist/index.js",
     "prepublish": "npm run build",
-    "posttest": "package-json-to-readme package.json > readme.md"
+    "posttest": "package-json-to-readme package.json --travis > readme.md"
   },
@@ -14,0 +14,0 @@ "repository": {

readme.md

@@ -1,2 +0,2 @@
-# immutable-object-methods 
+# immutable-object-methods [![Build Status](https://travis-ci.org/micnews/immutable-object-methods.png?branch=master)](https://travis-ci.org/micnews/immutable-object-methods)
 
@@ -16,3 +16,3 @@ Update normal plain javascript object, immutable style. Simlar to how immutable.js, seamless-immutable etc does it but a lot smaller and simpler.
 ```js
-import {setIn} from 'immutable-object-methods';
+import {getIn, setIn, mergeDeep, assign, set, without} from 'immutable-object-methods';
 
@@ -25,2 +25,26 @@ const input = {a: {b: 'c'}};
 
+const merged = mergeDeep(
+  {foo: 'bar'},
+  {beep: {boop: 4711}, foo: 'bas'}
+);
+console.log(merged);
+
+// immutable assign
+const assigned = assign({foo: 'bar'}, {foz: 'baz'});
+console.log(assigned);
+
+const value = getIn({a: {b: 'c'}}, ['a', 'b']);
+// will print out 'c'
+console.log(value);
+
+const noneExists = getIn({}, ['a', 'b']);
+// don't throw if value doesn't exists, just return undefined
+console.log(noneExists === undefined);
+
+const data = set({beep: 'boop'}, 'foo', 'bar');
+console.log(data);
+
+const beep = without({foo: 'bar'}, 'foo');
+console.log(beep);
+
 ```
@@ -27,0 +51,0 @@

test.js

 import test from 'ava';
 import 'babel-core/register';
-import {setIn} from './lib';
+import {assign, getIn, mergeDeep, setIn, set, without} from './lib';
 import objectMethods from './lib';
 
 test('default export', t => {
+  t.is(objectMethods.assign, assign);
+  t.is(objectMethods.getIn, getIn);
+  t.is(objectMethods.mergeDeep, mergeDeep);
   t.is(objectMethods.setIn, setIn);
+  t.is(objectMethods.set, set);
+  t.is(objectMethods.without, without);
 });
 
+test('set', t => {
+  const input = Object.freeze({a: 'b'});
+  const actual = set(input, 'foo', 'bar');
+  const expected = {
+    a: 'b',
+    foo: 'bar'
+  };
+  t.deepEqual(actual, expected);
+});
+
+test('set with unchanged data', t => {
+  const input = Object.freeze({foo: 'bar'});
+  const actual = set(input, 'foo', 'bar');
+  const expected = input;
+  t.is(actual, expected);
+});
+
 test('setIn', t => {
@@ -73,1 +95,173 @@ const input = Object.freeze({});
 });
+
+test('assign', t => {
+  const actual = assign(Object.freeze({}));
+  const expected = {};
+  t.deepEqual(actual, expected);
+  t.not(actual, expected);
+});
+
+test('assign multiple', t => {
+  const actual = assign(Object.freeze({a: 'b'}), Object.freeze({c: 'd'}));
+  const expected = {a: 'b', c: 'd'};
+  t.deepEqual(actual, expected);
+});
+
+test('mergeDeep', t => {
+  const input = Object.freeze({});
+  const changes = Object.freeze({
+    a: {
+      b: {
+        c: 'foo'
+      }
+    },
+    d: 'bar'
+  });
+  const actual = mergeDeep(input, changes);
+  const expected = changes;
+  t.deepEqual(actual, expected);
+});
+
+test('mergeDeep with unchanged array', t => {
+  const input = Object.freeze({
+    a: 'b',
+    c: [1, 2, 3]
+  });
+  const changes = Object.freeze({a: 'yo'});
+  const actual = mergeDeep(input, changes);
+  const expected = {
+    a: 'yo',
+    c: [1, 2, 3]
+  };
+  t.deepEqual(actual, expected);
+  t.is(actual.c, input.c);
+});
+
+test('mergeDeep with unchanged value', t => {
+  const input = Object.freeze({
+    a: {
+      b: 'c'
+    },
+    beep: 'boop'
+  });
+  const changes = Object.freeze({
+    a: {
+      b: 'c'
+    }
+  });
+  const actual = mergeDeep(input, changes);
+  const expected = input;
+  t.is(actual, expected);
+});
+
+test('mergeDeep with unchanged values', t => {
+  const input = Object.freeze({
+    a: {
+      b: 'c'
+    },
+    beep: 'boop',
+    foo: 'bar'
+  });
+  const changes = Object.freeze({
+    a: {
+      b: 'c'
+    },
+    beep: 'boop'
+  });
+  const actual = mergeDeep(input, changes);
+  const expected = input;
+  t.is(actual, expected);
+});
+
+test('mergeDeep with nested changed value', t => {
+  const input = Object.freeze({
+    a: {
+      b: 'c'
+    },
+    foo: 'bar'
+  });
+  const changes = Object.freeze({
+    a: {
+      b: 'd'
+    }
+  });
+  const actual = mergeDeep(input, changes);
+  const expected = {
+    a: {
+      b: 'd'
+    },
+    foo: 'bar'
+  };
+  t.deepEqual(actual, expected);
+});
+
+test('mergeDeep with null value, unchanged', t => {
+  const input = Object.freeze({
+    a: {
+      b: 0
+    },
+    c: false
+  });
+  const changes = Object.freeze({
+    a: {
+      b: 0
+    }
+  });
+  const actual = mergeDeep(input, changes);
+  const expected = input;
+  t.is(actual, expected);
+});
+
+test('getIn() with none object', t => {
+  const input = null;
+  const actual = getIn(input, ['a']);
+  t.is(actual, undefined);
+});
+
+test('getIn() with simple object & exists', t => {
+  const input = {
+    a: {b: 'c'}
+  };
+  const actual = getIn(input, ['a', 'b']);
+  const expected = 'c';
+  t.is(actual, expected);
+});
+
+test('getIn() with simple object & does not exists', t => {
+  const input = {
+    a: {b: 'c'}
+  };
+  const actual = getIn(input, ['foo', 'bar']);
+  t.is(actual, undefined);
+});
+
+test('without()', t => {
+  const input = Object.freeze({
+    a: 'b',
+    c: 'd'
+  });
+  const actual = without(input, 'c');
+  const expected = {
+    a: 'b'
+  };
+  t.deepEqual(actual, expected);
+});
+
+test('without() that does not change data', t => {
+  const input = Object.freeze({
+    a: 'b',
+    c: 'd'
+  });
+  const actual = without(input, 'not exists');
+  const expected = input;
+  t.deepEqual(actual, expected);
+});
+
+test('without() with falsy value', t => {
+  const input = Object.freeze({
+    foo: null
+  });
+  const actual = without(input, 'foo');
+  const expected = {};
+  t.deepEqual(actual, expected);
+});

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

17191

increased by171.97%

Number of package files

21

increased by162.5%

Lines of code

453

increased by277.5%

Number of lines in readme file

77

increased by45.28%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes