Socket
Socket
Sign inDemoInstall

immutable-ops

Package Overview
Dependencies
Maintainers
1
Versions
11
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

immutable-ops - npm Package Compare versions

Comparing version 0.5.0 to 0.5.1

.babelrc

249

lib/index.js

@@ -1,6 +0,43 @@

import curry from 'ramda/src/curry';
import placeholder from 'ramda/src/__';
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ops = exports.getBatchToken = undefined;
var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
var _assign = require('babel-runtime/core-js/object/assign');
var _assign2 = _interopRequireDefault(_assign);
var _defineProperty = require('babel-runtime/core-js/object/define-property');
var _defineProperty2 = _interopRequireDefault(_defineProperty);
var _symbol = require('babel-runtime/core-js/symbol');
var _symbol2 = _interopRequireDefault(_symbol);
var _typeof2 = require('babel-runtime/helpers/typeof');
var _typeof3 = _interopRequireDefault(_typeof2);
exports.canMutate = canMutate;
exports.getImmutableOps = getImmutableOps;
var _curry = require('ramda/src/curry');
var _curry2 = _interopRequireDefault(_curry);
var _ = require('ramda/src/__');
var _2 = _interopRequireDefault(_);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function forOwn(obj, fn) {
for (const key in obj) {
for (var key in obj) {
if (obj.hasOwnProperty(key)) {

@@ -13,10 +50,10 @@ fn(obj[key], key);

function isArrayLike(value) {
return value && typeof value === 'object' && typeof value.length === 'number' && value.length >= 0 && value.length % 1 === 0;
return value && (typeof value === 'undefined' ? 'undefined' : (0, _typeof3.default)(value)) === 'object' && typeof value.length === 'number' && value.length >= 0 && value.length % 1 === 0;
}
const OWNER_ID_TAG = '@@_______immutableOpsOwnerID';
var OWNER_ID_TAG = '@@_______immutableOpsOwnerID';
function fastArrayCopy(arr) {
const copied = new Array(arr.length);
for (let i = 0; i < arr.length; i++) {
var copied = new Array(arr.length);
for (var i = 0; i < arr.length; i++) {
copied[i] = arr[i];

@@ -27,3 +64,3 @@ }

export function canMutate(obj, ownerID) {
function canMutate(obj, ownerID) {
if (!ownerID) return false;

@@ -33,8 +70,12 @@ return obj[OWNER_ID_TAG] === ownerID;

const newOwnerID = typeof Symbol === 'function' ? () => Symbol('ownerID') : () => ({});
var newOwnerID = typeof _symbol2.default === 'function' ? function () {
return (0, _symbol2.default)('ownerID');
} : function () {
return {};
};
export const getBatchToken = newOwnerID;
var getBatchToken = exports.getBatchToken = newOwnerID;
function addOwnerID(obj, ownerID) {
Object.defineProperty(obj, OWNER_ID_TAG, {
(0, _defineProperty2.default)(obj, OWNER_ID_TAG, {
value: ownerID,

@@ -62,3 +103,3 @@ configurable: true,

const PATH_SEPARATOR = '.';
var PATH_SEPARATOR = '.';

@@ -82,6 +123,6 @@ function normalizePath(pathArg) {

function mutableSetIn(_pathArg, value, obj) {
const originalPathArg = normalizePath(_pathArg);
var originalPathArg = normalizePath(_pathArg);
const pathLen = originalPathArg.length;
originalPathArg.reduce((acc, curr, idx) => {
var pathLen = originalPathArg.length;
originalPathArg.reduce(function (acc, curr, idx) {
if (idx === pathLen - 1) {

@@ -92,6 +133,6 @@ acc[curr] = value;

const currType = typeof acc[curr];
var currType = (0, _typeof3.default)(acc[curr]);
if (currType === 'undefined') {
const newObj = {};
var newObj = {};
prepareNewObject(newObj, null);

@@ -106,4 +147,4 @@ acc[curr] = newObj;

const pathRepr = `${ originalPathArg[idx - 1] }.${ curr }`;
throw new Error(`A non-object value was encountered when traversing setIn path at ${ pathRepr }.`);
var pathRepr = originalPathArg[idx - 1] + '.' + curr;
throw new Error('A non-object value was encountered when traversing setIn path at ' + pathRepr + '.');
});

@@ -115,8 +156,8 @@

function valueInPath(_pathArg, obj) {
const pathArg = normalizePath(_pathArg);
var pathArg = normalizePath(_pathArg);
let acc = obj;
for (let i = 0; i < pathArg.length; i++) {
const curr = pathArg[i];
const currRef = acc[curr];
var acc = obj;
for (var i = 0; i < pathArg.length; i++) {
var curr = pathArg[i];
var currRef = acc[curr];
if (i === pathArg.length - 1) {

@@ -126,3 +167,3 @@ return currRef;

if (typeof currRef === 'object') {
if ((typeof currRef === 'undefined' ? 'undefined' : (0, _typeof3.default)(currRef)) === 'object') {
acc = currRef;

@@ -136,19 +177,19 @@ } else {

function immutableSetIn(ownerID, _pathArg, value, obj) {
const pathArg = normalizePath(_pathArg);
var pathArg = normalizePath(_pathArg);
const currentValue = valueInPath(pathArg, obj);
var currentValue = valueInPath(pathArg, obj);
if (value === currentValue) return obj;
const pathLen = pathArg.length;
var pathLen = pathArg.length;
let acc;
var acc = void 0;
if (canMutate(obj, ownerID)) {
acc = obj;
} else {
acc = Object.assign(prepareNewObject({}, ownerID), obj);
acc = (0, _assign2.default)(prepareNewObject({}, ownerID), obj);
}
const rootObj = acc;
var rootObj = acc;
pathArg.forEach((curr, idx) => {
pathArg.forEach(function (curr, idx) {
if (idx === pathLen - 1) {

@@ -159,4 +200,4 @@ acc[curr] = value;

const currRef = acc[curr];
const currType = typeof currRef;
var currRef = acc[curr];
var currType = typeof currRef === 'undefined' ? 'undefined' : (0, _typeof3.default)(currRef);

@@ -167,4 +208,4 @@ if (currType === 'object') {

} else {
const newObj = prepareNewObject({}, ownerID);
acc[curr] = Object.assign(newObj, currRef);
var newObj = prepareNewObject({}, ownerID);
acc[curr] = (0, _assign2.default)(newObj, currRef);
acc = newObj;

@@ -176,10 +217,10 @@ }

if (currType === 'undefined') {
const newObj = prepareNewObject({}, ownerID);
acc[curr] = newObj;
acc = newObj;
var _newObj = prepareNewObject({}, ownerID);
acc[curr] = _newObj;
acc = _newObj;
return;
}
const pathRepr = `${ pathArg[idx - 1] }.${ curr }`;
throw new Error(`A non-object value was encountered when traversing setIn path at ${ pathRepr }.`);
var pathRepr = pathArg[idx - 1] + '.' + curr;
throw new Error('A non-object value was encountered when traversing setIn path at ' + pathRepr + '.');
});

@@ -191,10 +232,10 @@

function mutableMerge(isDeep, _mergeObjs, baseObj) {
const mergeObjs = forceArray(_mergeObjs);
var mergeObjs = forceArray(_mergeObjs);
if (isDeep) {
mergeObjs.forEach(mergeObj => {
forOwn(mergeObj, (value, key) => {
mergeObjs.forEach(function (mergeObj) {
forOwn(mergeObj, function (value, key) {
if (isDeep && baseObj.hasOwnProperty(key)) {
let assignValue;
if (typeof value === 'object') {
var assignValue = void 0;
if ((typeof value === 'undefined' ? 'undefined' : (0, _typeof3.default)(value)) === 'object') {
assignValue = mutableMerge(isDeep, [value], baseObj[key]);

@@ -212,3 +253,3 @@ } else {

} else {
Object.assign(baseObj, ...mergeObjs);
_assign2.default.apply(Object, [baseObj].concat((0, _toConsumableArray3.default)(mergeObjs)));
}

@@ -219,8 +260,8 @@

const mutableShallowMerge = mutableMerge.bind(null, false);
const mutableDeepMerge = mutableMerge.bind(null, true);
var mutableShallowMerge = mutableMerge.bind(null, false);
var mutableDeepMerge = mutableMerge.bind(null, true);
function mutableOmit(_keys, obj) {
const keys = forceArray(_keys);
keys.forEach(key => {
var keys = forceArray(_keys);
keys.forEach(function (key) {
delete obj[key];

@@ -237,11 +278,11 @@ });

if (canMutate(obj, ownerID)) return mutableMerge(isDeep, _mergeObjs, obj);
const mergeObjs = forceArray(_mergeObjs);
var mergeObjs = forceArray(_mergeObjs);
let hasChanges = false;
let nextObject = obj;
var hasChanges = false;
var nextObject = obj;
const willChange = () => {
var willChange = function willChange() {
if (!hasChanges) {
hasChanges = true;
nextObject = Object.assign({}, obj);
nextObject = (0, _assign2.default)({}, obj);
prepareNewObject(nextObject, ownerID);

@@ -251,9 +292,9 @@ }

mergeObjs.forEach(mergeObj => {
forOwn(mergeObj, (mergeValue, key) => {
mergeObjs.forEach(function (mergeObj) {
forOwn(mergeObj, function (mergeValue, key) {
if (isDeep && obj.hasOwnProperty(key)) {
const currentValue = nextObject[key];
if (typeof mergeValue === 'object' && !(mergeValue instanceof Array)) {
var currentValue = nextObject[key];
if ((typeof mergeValue === 'undefined' ? 'undefined' : (0, _typeof3.default)(mergeValue)) === 'object' && !(mergeValue instanceof Array)) {
if (_shouldMergeKey(nextObject, mergeObj, key)) {
const recursiveMergeResult = immutableMerge(isDeep, ownerID, mergeValue, currentValue);
var recursiveMergeResult = immutableMerge(isDeep, ownerID, mergeValue, currentValue);

@@ -278,4 +319,4 @@ if (recursiveMergeResult !== currentValue) {

const immutableDeepMerge = immutableMerge.bind(null, true);
const immutableShallowMerge = immutableMerge.bind(null, false);
var immutableDeepMerge = immutableMerge.bind(null, true);
var immutableShallowMerge = immutableMerge.bind(null, false);

@@ -287,3 +328,3 @@ function immutableArrSet(ownerID, index, value, arr) {

const newArr = fastArrayCopy(arr);
var newArr = fastArrayCopy(arr);
newArr[index] = value;

@@ -301,3 +342,3 @@ prepareNewObject(newArr, ownerID);

const newObj = Object.assign({}, obj);
var newObj = (0, _assign2.default)({}, obj);
prepareNewObject(newObj, ownerID);

@@ -311,4 +352,6 @@ newObj[key] = value;

const keys = forceArray(_keys);
const keysInObj = keys.filter(key => obj.hasOwnProperty(key));
var keys = forceArray(_keys);
var keysInObj = keys.filter(function (key) {
return obj.hasOwnProperty(key);
});

@@ -318,4 +361,4 @@ // None of the keys were in the object, so we can return `obj`.

const newObj = Object.assign({}, obj);
keysInObj.forEach(key => {
var newObj = (0, _assign2.default)({}, obj);
keysInObj.forEach(function (key) {
delete newObj[key];

@@ -328,4 +371,4 @@ });

function mutableArrPush(_vals, arr) {
const vals = forceArray(_vals);
arr.push(...vals);
var vals = forceArray(_vals);
arr.push.apply(arr, (0, _toConsumableArray3.default)(vals));
return arr;

@@ -335,6 +378,6 @@ }

function mutableArrFilter(func, arr) {
let currIndex = 0;
let originalIndex = 0;
var currIndex = 0;
var originalIndex = 0;
while (currIndex < arr.length) {
const item = arr[currIndex];
var item = arr[currIndex];
if (!func(item, originalIndex)) {

@@ -352,4 +395,4 @@ arr.splice(currIndex, 1);

function mutableArrSplice(index, deleteCount, _vals, arr) {
const vals = forceArray(_vals);
arr.splice(index, deleteCount, ...vals);
var vals = forceArray(_vals);
arr.splice.apply(arr, [index, deleteCount].concat((0, _toConsumableArray3.default)(vals)));
return arr;

@@ -365,6 +408,6 @@ }

const vals = forceArray(_vals);
const newArr = arr.slice();
var vals = forceArray(_vals);
var newArr = arr.slice();
prepareNewObject(newArr, ownerID);
newArr.splice(index, deleteCount, ...vals);
newArr.splice.apply(newArr, [index, deleteCount].concat((0, _toConsumableArray3.default)(vals)));

@@ -385,3 +428,3 @@ return newArr;

if (canMutate(arr, ownerID)) return mutableArrFilter(func, arr);
const newArr = arr.filter(func);
var newArr = arr.filter(func);

@@ -394,3 +437,3 @@ if (newArr.length === arr.length) return arr;

const immutableOperations = {
var immutableOperations = {
// object operations

@@ -412,3 +455,3 @@ merge: immutableShallowMerge,

const mutableOperations = {
var mutableOperations = {
// object operations

@@ -430,21 +473,21 @@ merge: mutableShallowMerge,

export function getImmutableOps() {
const immutableOps = Object.assign({}, immutableOperations);
forOwn(immutableOps, (value, key) => {
immutableOps[key] = curry(value.bind(null, null));
function getImmutableOps() {
var immutableOps = (0, _assign2.default)({}, immutableOperations);
forOwn(immutableOps, function (value, key) {
immutableOps[key] = (0, _curry2.default)(value.bind(null, null));
});
const mutableOps = Object.assign({}, mutableOperations);
forOwn(mutableOps, (value, key) => {
mutableOps[key] = curry(value);
var mutableOps = (0, _assign2.default)({}, mutableOperations);
forOwn(mutableOps, function (value, key) {
mutableOps[key] = (0, _curry2.default)(value);
});
const batchOps = Object.assign({}, immutableOperations);
forOwn(batchOps, (value, key) => {
batchOps[key] = curry(value);
var batchOps = (0, _assign2.default)({}, immutableOperations);
forOwn(batchOps, function (value, key) {
batchOps[key] = (0, _curry2.default)(value);
});
function batched(_token, _fn) {
let token;
let fn;
var token = void 0;
var fn = void 0;

@@ -459,5 +502,5 @@ if (typeof _token === 'function') {

const immutableOpsBoundToToken = Object.assign({}, immutableOperations);
forOwn(immutableOpsBoundToToken, (value, key) => {
immutableOpsBoundToToken[key] = curry(value.bind(null, token));
var immutableOpsBoundToToken = (0, _assign2.default)({}, immutableOperations);
forOwn(immutableOpsBoundToToken, function (value, key) {
immutableOpsBoundToToken[key] = (0, _curry2.default)(value.bind(null, token));
});

@@ -467,13 +510,13 @@ return fn(immutableOpsBoundToToken);

return Object.assign(immutableOps, {
return (0, _assign2.default)(immutableOps, {
mutable: mutableOps,
batch: batchOps,
batched,
__: placeholder,
getBatchToken
batched: batched,
__: _2.default,
getBatchToken: getBatchToken
});
}
export const ops = getImmutableOps();
var ops = exports.ops = getImmutableOps();
export default ops;
exports.default = ops;

351

lib/test/testOperations.js

@@ -1,19 +0,32 @@

import chai from 'chai';
import sinonChai from 'sinon-chai';
import freeze from 'deep-freeze';
'use strict';
import { ops, canMutate, getBatchToken } from '../index';
var _chai = require('chai');
chai.use(sinonChai);
const { expect } = chai;
var _chai2 = _interopRequireDefault(_chai);
describe('batched', () => {
it('works', () => {
const res = ops.batched(batchOps => {
const obj = {};
const result = batchOps.set('a', 1, obj);
var _sinonChai = require('sinon-chai');
var _sinonChai2 = _interopRequireDefault(_sinonChai);
var _deepFreeze = require('deep-freeze');
var _deepFreeze2 = _interopRequireDefault(_deepFreeze);
var _index = require('../index');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
_chai2.default.use(_sinonChai2.default);
var expect = _chai2.default.expect;
describe('batched', function () {
it('works', function () {
var res = _index.ops.batched(function (batchOps) {
var obj = {};
var result = batchOps.set('a', 1, obj);
expect(result).to.deep.equal({ a: 1 });
expect(result).not.to.equal(obj);
const result2 = batchOps.omit('a', result);
var result2 = batchOps.omit('a', result);
expect(result2).to.equal(result);

@@ -28,8 +41,8 @@ expect(result2).to.deep.equal({});

describe('operations', () => {
describe('object', () => {
describe('batched mutations', () => {
const token = getBatchToken();
it('deepMerges', () => {
const baseObj = freeze({
describe('operations', function () {
describe('object', function () {
describe('batched mutations', function () {
var token = (0, _index.getBatchToken)();
it('deepMerges', function () {
var baseObj = (0, _deepFreeze2.default)({
change: 'Tommi',

@@ -42,3 +55,3 @@ dontChange: 25,

});
const mergeObj = freeze({
var mergeObj = (0, _deepFreeze2.default)({
change: 'None',

@@ -51,9 +64,9 @@ add: 'US',

});
const merger = ops.batch.deepMerge(token, mergeObj);
const result = merger(baseObj);
expect(canMutate(result, token)).to.be.true;
expect(canMutate(result.deeper, token)).to.be.true;
var merger = _index.ops.batch.deepMerge(token, mergeObj);
var result = merger(baseObj);
expect((0, _index.canMutate)(result, token)).to.be.true;
expect((0, _index.canMutate)(result.deeper, token)).to.be.true;
expect(canMutate(result, getBatchToken())).to.be.false;
expect(canMutate(result.deeper, getBatchToken())).to.be.false;
expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
expect((0, _index.canMutate)(result.deeper, (0, _index.getBatchToken)())).to.be.false;

@@ -72,4 +85,4 @@ expect(result).to.not.equal(baseObj);

it('omits a single key', () => {
const obj = freeze({
it('omits a single key', function () {
var obj = (0, _deepFreeze2.default)({
name: 'Tommi',

@@ -79,16 +92,16 @@ age: 25

const omitter = ops.batch.omit(token, 'age');
var omitter = _index.ops.batch.omit(token, 'age');
const result = omitter(obj);
expect(canMutate(result, token)).to.be.true;
var result = omitter(obj);
expect((0, _index.canMutate)(result, token)).to.be.true;
expect(canMutate(result, getBatchToken())).to.be.false;
expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
expect(result).to.not.contain.keys(['age']);
// Further modification should mutate the existing object.
expect(ops.batch.omit(token, 'name', result)).to.equal(result);
expect(_index.ops.batch.omit(token, 'name', result)).to.equal(result);
});
it('omits an array of keys', () => {
const obj = freeze({
it('omits an array of keys', function () {
var obj = (0, _deepFreeze2.default)({
name: 'Tommi',

@@ -98,16 +111,16 @@ age: 25

const omitter = ops.batch.omit(token, ['age']);
const result = omitter(obj);
var omitter = _index.ops.batch.omit(token, ['age']);
var result = omitter(obj);
expect(canMutate(result, token)).to.be.true;
expect((0, _index.canMutate)(result, token)).to.be.true;
expect(canMutate(result, getBatchToken())).to.be.false;
expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
expect(result).to.not.contain.keys(['age']);
// Further modification should mutate the existing object.
expect(ops.batch.omit(token, ['name'], result)).to.equal(result);
expect(_index.ops.batch.omit(token, ['name'], result)).to.equal(result);
});
it('sets a value', () => {
const obj = freeze({
it('sets a value', function () {
var obj = (0, _deepFreeze2.default)({
one: 1,

@@ -118,6 +131,6 @@ two: 500,

const result = ops.batch.set(token, 'two', 5, obj);
var result = _index.ops.batch.set(token, 'two', 5, obj);
expect(canMutate(result, token)).to.be.true;
const result2 = ops.batch.set(token, 'two', 2, result);
expect((0, _index.canMutate)(result, token)).to.be.true;
var result2 = _index.ops.batch.set(token, 'two', 2, result);
expect(result2).to.deep.equal({

@@ -132,4 +145,4 @@ one: 1,

it('sets a value in path', () => {
const obj = freeze({
it('sets a value in path', function () {
var obj = (0, _deepFreeze2.default)({
first: {

@@ -145,8 +158,8 @@ second: {

const setter = ops.batch.setIn(token, 'first.second.value', 'anotherValue');
var setter = _index.ops.batch.setIn(token, 'first.second.value', 'anotherValue');
const result = setter(obj);
expect(canMutate(result, token)).to.be.true;
var result = setter(obj);
expect((0, _index.canMutate)(result, token)).to.be.true;
expect(canMutate(result, getBatchToken())).to.be.false;
expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
expect(result).not.to.equal(obj);

@@ -158,3 +171,3 @@ expect(result.first.second.value).to.equal('anotherValue');

const result2 = ops.batch.setIn(token, 'first.second.value', 'secondAnotherValue', result);
var result2 = _index.ops.batch.setIn(token, 'first.second.value', 'secondAnotherValue', result);
expect(result).to.equal(result2);

@@ -165,5 +178,5 @@ expect(result2.first.second.value).to.equal('secondAnotherValue');

describe('immutable ops', () => {
it('deepMerges', () => {
const baseObj = freeze({
describe('immutable ops', function () {
it('deepMerges', function () {
var baseObj = (0, _deepFreeze2.default)({
change: 'Tommi',

@@ -176,3 +189,3 @@ dontChange: 25,

});
const mergeObj = freeze({
var mergeObj = (0, _deepFreeze2.default)({
change: 'None',

@@ -186,7 +199,7 @@ add: 'US',

const merger = ops.deepMerge(mergeObj);
const result = merger(baseObj);
var merger = _index.ops.deepMerge(mergeObj);
var result = merger(baseObj);
expect(canMutate(result)).to.be.false;
expect(canMutate(result.deeper)).to.be.false;
expect((0, _index.canMutate)(result)).to.be.false;
expect((0, _index.canMutate)(result.deeper)).to.be.false;

@@ -205,4 +218,4 @@ expect(result).to.not.equal(baseObj);

it('deepMerges and returns initial object when no values changed', () => {
const baseObj = freeze({
it('deepMerges and returns initial object when no values changed', function () {
var baseObj = (0, _deepFreeze2.default)({
deep: {

@@ -212,3 +225,3 @@ dontChange: 'John'

});
const mergeObj = freeze({
var mergeObj = (0, _deepFreeze2.default)({
deep: {

@@ -219,8 +232,8 @@ dontChange: 'John'

const result = ops.deepMerge(mergeObj, baseObj);
var result = _index.ops.deepMerge(mergeObj, baseObj);
expect(result).to.equal(baseObj);
});
it('omits a single key', () => {
const obj = freeze({
it('omits a single key', function () {
var obj = (0, _deepFreeze2.default)({
name: 'Tommi',

@@ -230,11 +243,11 @@ age: 25

const omitter = ops.omit('age');
const result = omitter(obj);
var omitter = _index.ops.omit('age');
var result = omitter(obj);
expect(canMutate(result)).to.be.false;
expect((0, _index.canMutate)(result)).to.be.false;
expect(result).to.not.contain.keys(['age']);
});
it('omits a single key, returns same object if no value changes', () => {
const obj = freeze({
it('omits a single key, returns same object if no value changes', function () {
var obj = (0, _deepFreeze2.default)({
name: 'Tommi',

@@ -244,8 +257,8 @@ age: 25

const result = ops.omit('location', obj);
var result = _index.ops.omit('location', obj);
expect(result).to.equal(obj);
});
it('omits an array of keys', () => {
const obj = freeze({
it('omits an array of keys', function () {
var obj = (0, _deepFreeze2.default)({
name: 'Tommi',

@@ -255,11 +268,11 @@ age: 25

const omitter = ops.omit(['age']);
const result = omitter(obj);
var omitter = _index.ops.omit(['age']);
var result = omitter(obj);
expect(canMutate(result)).to.be.false;
expect((0, _index.canMutate)(result)).to.be.false;
expect(result).to.not.contain.keys(['age']);
});
it('sets a value', () => {
const obj = freeze({
it('sets a value', function () {
var obj = (0, _deepFreeze2.default)({
name: 'Tommi',

@@ -269,3 +282,3 @@ age: 25

const result = ops.set('age', 26, obj);
var result = _index.ops.set('age', 26, obj);
expect(result).to.deep.equal({

@@ -277,4 +290,4 @@ name: 'Tommi',

it('sets a value and returns the initial value of no changes', () => {
const obj = freeze({
it('sets a value and returns the initial value of no changes', function () {
var obj = (0, _deepFreeze2.default)({
name: 'Tommi',

@@ -284,8 +297,8 @@ age: 25

const result = ops.set('age', 25, obj);
var result = _index.ops.set('age', 25, obj);
expect(result).to.equal(obj);
});
it('sets a value in path', () => {
const obj = freeze({
it('sets a value in path', function () {
var obj = (0, _deepFreeze2.default)({
first: {

@@ -301,7 +314,7 @@ second: {

const setter = ops.setIn('first.second.value', 'anotherValue');
var setter = _index.ops.setIn('first.second.value', 'anotherValue');
const result = setter(obj);
var result = setter(obj);
expect(canMutate(result)).to.be.false;
expect((0, _index.canMutate)(result)).to.be.false;
expect(result).not.to.equal(obj);

@@ -314,4 +327,4 @@ expect(result.first.second.value).to.equal('anotherValue');

it('sets a value in path but returns same object if no value changes', () => {
const obj = freeze({
it('sets a value in path but returns same object if no value changes', function () {
var obj = (0, _deepFreeze2.default)({
first: {

@@ -327,3 +340,3 @@ second: {

const result = ops.setIn('first.second.value', 'value', obj);
var result = _index.ops.setIn('first.second.value', 'value', obj);
expect(result).to.equal(obj);

@@ -334,11 +347,11 @@ });

describe('array', () => {
describe('batched mutations', () => {
const token = getBatchToken();
describe('array', function () {
describe('batched mutations', function () {
var token = (0, _index.getBatchToken)();
it('push', () => {
const push = ops.batch.push;
const arr = freeze([5, 4]);
const pusher = push(token, freeze([1, 2, 3]));
const result = pusher(arr);
it('push', function () {
var push = _index.ops.batch.push;
var arr = (0, _deepFreeze2.default)([5, 4]);
var pusher = push(token, (0, _deepFreeze2.default)([1, 2, 3]));
var result = pusher(arr);

@@ -349,3 +362,3 @@ expect(result).to.not.equal(arr);

const result2 = push(token, [4, 5], result);
var result2 = push(token, [4, 5], result);
expect(result).to.equal(result2);

@@ -355,11 +368,11 @@ expect(result2).to.deep.equal([5, 4, 1, 2, 3, 4, 5]);

it('insert', () => {
const insert = ops.batch.insert;
const arr = freeze([1, 2, 5]);
const inserter = insert(token, 2, freeze([3, 4]));
const result = inserter(arr);
it('insert', function () {
var insert = _index.ops.batch.insert;
var arr = (0, _deepFreeze2.default)([1, 2, 5]);
var inserter = insert(token, 2, (0, _deepFreeze2.default)([3, 4]));
var result = inserter(arr);
expect(result).to.deep.equal([1, 2, 3, 4, 5]);
const result2 = ops.batch.insert(token, 2, [1000], result);
var result2 = _index.ops.batch.insert(token, 2, [1000], result);
expect(result).to.equal(result2);

@@ -369,11 +382,15 @@ expect(result2).to.deep.equal([1, 2, 1000, 3, 4, 5]);

it('filter', () => {
const arr = freeze([0, 1, 2, 3]);
const result = ops.batch.filter(token, item => item % 2 === 0, arr);
expect(canMutate(result, token)).to.be.true;
it('filter', function () {
var arr = (0, _deepFreeze2.default)([0, 1, 2, 3]);
var result = _index.ops.batch.filter(token, function (item) {
return item % 2 === 0;
}, arr);
expect((0, _index.canMutate)(result, token)).to.be.true;
expect(result).to.deep.equal([0, 2]);
expect(canMutate(result, getBatchToken())).to.be.false;
expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
const result2 = ops.batch.filter(token, item => item === 2, result);
var result2 = _index.ops.batch.filter(token, function (item) {
return item === 2;
}, result);
expect(result2).to.equal(result);

@@ -383,13 +400,13 @@ expect(result2).to.deep.equal([2]);

it('set', () => {
const arr = freeze([1, 2, 987, 4]);
it('set', function () {
var arr = (0, _deepFreeze2.default)([1, 2, 987, 4]);
const setter = ops.batch.set(token, 2, 3);
const result = setter(arr);
expect(canMutate(result, token)).to.be.true;
var setter = _index.ops.batch.set(token, 2, 3);
var result = setter(arr);
expect((0, _index.canMutate)(result, token)).to.be.true;
expect(canMutate(result, getBatchToken())).to.be.false;
expect((0, _index.canMutate)(result, (0, _index.getBatchToken)())).to.be.false;
expect(result).to.deep.equal([1, 2, 3, 4]);
const result2 = ops.batch.set(token, 2, 1000, result);
var result2 = _index.ops.batch.set(token, 2, 1000, result);
expect(result).to.equal(result2);

@@ -399,12 +416,12 @@ expect(result2).to.deep.equal([1, 2, 1000, 4]);

it('splice with deletions', () => {
const splice = ops.batch.splice;
const arr = freeze([1, 2, 3, 3, 3, 4]);
const splicer = splice(token, 2, 2, []);
it('splice with deletions', function () {
var splice = _index.ops.batch.splice;
var arr = (0, _deepFreeze2.default)([1, 2, 3, 3, 3, 4]);
var splicer = splice(token, 2, 2, []);
const result = splicer(arr);
var result = splicer(arr);
expect(result).to.deep.equal([1, 2, 3, 4]);
const result2 = ops.batch.splice(token, 2, 1, [], result);
var result2 = _index.ops.batch.splice(token, 2, 1, [], result);
expect(result2).to.equal(result);

@@ -414,12 +431,12 @@ expect(result2).to.deep.equal([1, 2, 4]);

it('splice with additions', () => {
const splice = ops.batch.splice;
const arr = freeze([1, 5]);
const splicer = splice(token, 1, 0, [2, 3, 4]);
it('splice with additions', function () {
var splice = _index.ops.batch.splice;
var arr = (0, _deepFreeze2.default)([1, 5]);
var splicer = splice(token, 1, 0, [2, 3, 4]);
const result = splicer(arr);
var result = splicer(arr);
expect(result).to.deep.equal([1, 2, 3, 4, 5]);
const result2 = ops.batch.splice(token, 0, 1, [1000], result);
var result2 = _index.ops.batch.splice(token, 0, 1, [1000], result);
expect(result).to.equal(result2);

@@ -430,8 +447,8 @@ expect(result2).to.deep.equal([1000, 2, 3, 4, 5]);

describe('immutable ops', () => {
it('push', () => {
const push = ops.push;
const arr = freeze([5, 4]);
const pusher = push(freeze([1, 2, 3]));
const result = pusher(arr);
describe('immutable ops', function () {
it('push', function () {
var push = _index.ops.push;
var arr = (0, _deepFreeze2.default)([5, 4]);
var pusher = push((0, _deepFreeze2.default)([1, 2, 3]));
var result = pusher(arr);

@@ -443,7 +460,7 @@ expect(result).to.not.equal(arr);

it('insert', () => {
const insert = ops.insert;
const arr = freeze([1, 2, 5]);
const inserter = insert(2, freeze([3, 4]));
const result = inserter(arr);
it('insert', function () {
var insert = _index.ops.insert;
var arr = (0, _deepFreeze2.default)([1, 2, 5]);
var inserter = insert(2, (0, _deepFreeze2.default)([3, 4]));
var result = inserter(arr);

@@ -453,48 +470,52 @@ expect(result).to.deep.equal([1, 2, 3, 4, 5]);

it('filter', () => {
const arr = freeze([0, 1, 2, 3]);
it('filter', function () {
var arr = (0, _deepFreeze2.default)([0, 1, 2, 3]);
const result = ops.filter(item => item % 2 === 0, arr);
var result = _index.ops.filter(function (item) {
return item % 2 === 0;
}, arr);
expect(result).to.deep.equal([0, 2]);
expect(canMutate(result)).to.be.false;
expect((0, _index.canMutate)(result)).to.be.false;
});
it('filter with no effect should return initial array', () => {
const arr = freeze([0, 1, 2, 3]);
const result = ops.filter(item => item < 4, arr);
it('filter with no effect should return initial array', function () {
var arr = (0, _deepFreeze2.default)([0, 1, 2, 3]);
var result = _index.ops.filter(function (item) {
return item < 4;
}, arr);
expect(result).to.equal(arr);
});
it('set', () => {
const arr = freeze([1, 2, 987, 4]);
it('set', function () {
var arr = (0, _deepFreeze2.default)([1, 2, 987, 4]);
const result = ops.set(2, 3, arr);
var result = _index.ops.set(2, 3, arr);
expect(canMutate(result)).to.be.false;
expect((0, _index.canMutate)(result)).to.be.false;
expect(result).to.deep.equal([1, 2, 3, 4]);
});
it('set with no effect should return initial array', () => {
const arr = freeze([1, 2, 3, 4]);
it('set with no effect should return initial array', function () {
var arr = (0, _deepFreeze2.default)([1, 2, 3, 4]);
const result = ops.set(2, 3, arr);
var result = _index.ops.set(2, 3, arr);
expect(result).to.equal(arr);
});
it('splice with deletions', () => {
const splice = ops.splice;
const arr = freeze([1, 2, 3, 3, 3, 4]);
const splicer = splice(2, 2, []);
it('splice with deletions', function () {
var splice = _index.ops.splice;
var arr = (0, _deepFreeze2.default)([1, 2, 3, 3, 3, 4]);
var splicer = splice(2, 2, []);
const result = splicer(arr);
var result = splicer(arr);
expect(result).to.deep.equal([1, 2, 3, 4]);
});
it('splice with additions', () => {
const splice = ops.splice;
const arr = freeze([1, 5]);
const splicer = splice(1, 0, [2, 3, 4]);
it('splice with additions', function () {
var splice = _index.ops.splice;
var arr = (0, _deepFreeze2.default)([1, 5]);
var splicer = splice(1, 0, [2, 3, 4]);
const result = splicer(arr);
var result = splicer(arr);

@@ -501,0 +522,0 @@ expect(result).to.deep.equal([1, 2, 3, 4, 5]);

5

package.json
{
"name": "immutable-ops",
"version": "0.5.0",
"version": "0.5.1",
"description": "A collection of functions to perform immutable operations on plain JavaScript objects",

@@ -21,2 +21,5 @@ "main": "lib/index.js",

"babel-eslint": "^7.1.0",
"babel-plugin-transform-runtime": "^6.15.0",
"babel-preset-es2015": "^6.18.0",
"babel-preset-stage-2": "^6.18.0",
"chai": "^3.5.0",

@@ -23,0 +26,0 @@ "deep-freeze": "0.0.1",

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc