immutable 4.0.0-rc.12 → 4.0.0-rc.14

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "immutable",
-  "version": "4.0.0-rc.12",
+  "version": "4.0.0-rc.14",
   "description": "Immutable Data Collections",
   "license": "MIT",
-  "homepage": "https://facebook.github.com/immutable-js",
+  "homepage": "https://immutable-js.com",
   "author": {
     "name": "Lee Byron",
     "url": "https://github.com/leebyron"
   },
   "repository": {
     "type": "git",
-    "url": "git://github.com/facebook/immutable-js.git"
+    "url": "git://github.com/immutable-js/immutable-js.git"
   },
   "bugs": {
-    "url": "https://github.com/facebook/immutable-js/issues"
+    "url": "https://github.com/immutable-js/immutable-js/issues"
   },
   "main": "dist/immutable.js",
   "module": "dist/immutable.es.js",
@@ -21,95 +21,8 @@
   "typescript": {
     "definition": "dist/immutable.d.ts"
   },
-  "scripts": {
-    "build": "run-s build:*",
-    "build:dist": "run-s clean:dist bundle:dist bundle:es copy:dist stats:dist",
-    "build:pages": "gulp --gulpfile ./resources/gulpfile.js default",
-    "stats:dist": "node ./resources/dist-stats.js",
-    "clean:dist": "rimraf dist",
-    "bundle:dist": "rollup -c ./resources/rollup-config.js",
-    "bundle:es": "rollup -c ./resources/rollup-config-es.js",
-    "copy:dist": "node ./resources/copy-dist-typedefs.js",
-    "lint": "run-s lint:*",
-    "lint:ts": "tslint \"__tests__/**/*.ts\"",
-    "lint:js": "eslint \"{__tests__,src,pages/src,pages/lib}/**/*.js\"",
-    "format": "prettier --single-quote --trailing-comma=es5 --write \"{__tests__,src,pages/src,pages/lib,perf,resources}/**/*{\\.js,\\.ts}\"",
-    "testonly": "./resources/jest",
-    "test": "run-s format build lint testonly test:types:*",
-    "test:travis": "npm run test && ./resources/check-changes",
-    "test:types:ts": "tsc ./type-definitions/Immutable.d.ts --lib es2015 && dtslint type-definitions/ts-tests",
-    "test:types:flow": "flow check type-definitions/tests --include-warnings",
-    "perf": "node ./resources/bench.js",
-    "start": "gulp --gulpfile ./resources/gulpfile.js dev",
-    "deploy": "./resources/deploy-ghpages.sh",
-    "gitpublish": "./resources/gitpublish.sh"
-  },
-  "jest": {
-    "moduleFileExtensions": [
-      "js",
-      "ts"
-    ],
-    "transform": {
-      "^.+\\.ts$": "<rootDir>/resources/jestPreprocessor.js"
-    },
-    "testRegex": "/__tests__/.*\\.(ts|js)$",
-    "unmockedModulePathPatterns": [
-      "./node_modules/react"
-    ]
-  },
-  "devDependencies": {
-    "benchmark": "2.1.4",
-    "browser-sync": "^2.26.3",
-    "browserify": "16.2.2",
-    "colors": "1.2.5",
-    "del": "3.0.0",
-    "dtslint": "0.1.2",
-    "eslint": "4.19.1",
-    "eslint-config-airbnb": "16.1.0",
-    "eslint-config-prettier": "2.9.0",
-    "eslint-plugin-import": "2.12.0",
-    "eslint-plugin-jsx-a11y": "6.0.3",
-    "eslint-plugin-prettier": "2.6.2",
-    "eslint-plugin-react": "7.8.2",
-    "flow-bin": "0.85.0",
-    "gulp": "3.9.1",
-    "gulp-concat": "2.6.1",
-    "gulp-filter": "5.1.0",
-    "gulp-header": "2.0.5",
-    "gulp-less": "3.5.0",
-    "gulp-size": "3.0.0",
-    "gulp-sourcemaps": "2.6.4",
-    "gulp-uglify": "2.1.0",
-    "gulp-util": "3.0.8",
-    "jasmine-check": "0.1.5",
-    "jest": "23.6.0",
-    "marked": "0.3.19",
-    "microtime": "2.1.8",
-    "mkdirp": "0.5.1",
-    "npm-run-all": "4.1.3",
-    "prettier": "1.14.2",
-    "react": "^0.12.0",
-    "react-router": "^0.11.2",
-    "react-tools": "0.13.3",
-    "rimraf": "2.6.2",
-    "rollup": "0.59.1",
-    "rollup-plugin-buble": "0.19.2",
-    "rollup-plugin-commonjs": "9.1.3",
-    "rollup-plugin-json": "3.0.0",
-    "rollup-plugin-strip-banner": "0.2.0",
-    "run-sequence": "2.2.1",
-    "through2": "2.0.3",
-    "transducers-js": "^0.4.174",
-    "tslint": "5.7.0",
-    "typescript": "3.0.3",
-    "uglify-js": "2.8.11",
-    "uglify-save-license": "0.4.1",
-    "vinyl-buffer": "1.0.1",
-    "vinyl-source-stream": "2.0.0"
-  },
   "files": [
     "dist",
-    "contrib",
     "README.md",
     "LICENSE"
   ],
@@ -124,6 +37,5 @@
     "stateless",
     "sequence",
     "iteration"
-  ],
-  "dependencies": {}
-}
+  ]
+}

package/contrib/cursor/README.md

@@ -1,43 +0,0 @@
-# DEPRECATED
-
-The Cursor API is deprecated and will be removed in a future major release.
-
-It is strongly suggested that you use the excellent `immutable-cursor` module
-which has an extremely similar API but is much higher quality.
-
-https://github.com/redbadger/immutable-cursor
-
-
-Cursors
--------
-
-Cursors allow you to hold a reference to a path in a nested immutable data
-structure, allowing you to pass smaller sections of a larger nested
-collection to portions of your application while maintaining a central point
-aware of changes to the entire data structure: an `onChange` function which is
-called whenever a cursor or sub-cursor calls `update`.
-
-This is particularly useful when used in conjunction with component-based UI
-libraries like [React](https://facebook.github.io/react/) or to simulate
-"state" throughout an application while maintaining a single flow of logic.
-
-
-```javascript
-var Immutable = require('immutable');
-var Cursor = require('immutable/contrib/cursor');
-
-var data = Immutable.fromJS({ a: { b: { c: 1 } } });
-var cursor = Cursor.from(data, ['a', 'b'], newData => {
-  data = newData;
-});
-
-// ... elsewhere ...
-
-cursor.get('c'); // 1
-cursor = cursor.update('c', x => x + 1);
-cursor.get('c'); // 2
-
-// ... back to data ...
-
-data.getIn(['a', 'b', 'c']); // 2
-```

package/contrib/cursor/__tests__/Cursor.ts.skip

@@ -1,395 +0,0 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-///<reference path='../../../resources/jest.d.ts'/>
-
-import * as Immutable from '../../../';
-import * as Cursor from '../';
-
-describe('Cursor', () => {
-
-  beforeEach(function () {
-    jasmine.addMatchers({
-      toValueEqual: function(actual, expected) {
-        var passed = Immutable.is(actual, expected);
-        return {
-          pass: passed,
-          message: 'Expected ' + actual + (passed ? '' : ' not') + ' to equal ' + expected
-        };
-      }
-    });
-  });
-
-  var json = { a: { b: { c: 1 } } };
-
-  it('gets from its path', () => {
-    var data = Immutable.fromJS(json);
-    var cursor = Cursor.from(data);
-
-    expect(cursor.deref()).toBe(data);
-
-    var deepCursor = cursor.cursor(['a', 'b']);
-    expect(deepCursor.deref().toJS()).toEqual(json.a.b);
-    expect(deepCursor.deref()).toBe(data.getIn(['a', 'b']));
-    expect(deepCursor.get('c')).toBe(1);
-
-    var leafCursor = deepCursor.cursor('c');
-    expect(leafCursor.deref()).toBe(1);
-
-    var missCursor = leafCursor.cursor('d');
-    expect(missCursor.deref()).toBe(undefined);
-  });
-
-  it('gets return new cursors', () => {
-    var data = Immutable.fromJS(json);
-    var cursor = Cursor.from(data);
-    var deepCursor = cursor.getIn(['a', 'b']);
-    expect(deepCursor.deref()).toBe(data.getIn(['a', 'b']));
-  });
-
-  it('gets return new cursors using List', () => {
-    var data = Immutable.fromJS(json);
-    var cursor = Cursor.from(data);
-    var deepCursor = cursor.getIn(Immutable.fromJS(['a', 'b']));
-    expect(deepCursor.deref()).toBe(data.getIn(Immutable.fromJS(['a', 'b'])));
-  });
-
-  it('cursor return new cursors of correct type', () => {
-    var data = Immutable.fromJS({ a: [1, 2, 3] });
-    var cursor = Cursor.from(data);
-    var deepCursor = <any>cursor.cursor('a');
-    expect(deepCursor.findIndex).toBeDefined();
-  });
-
-  it('can be treated as a value', () => {
-    var data = Immutable.fromJS(json);
-    var cursor = Cursor.from(data, ['a', 'b']);
-    expect(cursor.toJS()).toEqual(json.a.b);
-    expect(cursor).toValueEqual(data.getIn(['a', 'b']));
-    expect(cursor.size).toBe(1);
-    expect(cursor.get('c')).toBe(1);
-  });
-
-  it('can be value compared to a primitive', () => {
-    var data = Immutable.Map({ a: 'A' });
-    var aCursor = Cursor.from(data, 'a');
-    expect(aCursor.size).toBe(undefined);
-    expect(aCursor.deref()).toBe('A');
-    expect(Immutable.is(aCursor, 'A')).toBe(true);
-  });
-
-  it('updates at its path', () => {
-    var onChange = jest.genMockFunction();
-
-    var data = Immutable.fromJS(json);
-    var aCursor = Cursor.from(data, 'a', onChange);
-
-    var deepCursor = aCursor.cursor(['b', 'c']);
-    expect(deepCursor.deref()).toBe(1);
-
-    // cursor edits return new cursors:
-    var newDeepCursor = deepCursor.update(x => x + 1);
-    expect(newDeepCursor.deref()).toBe(2);
-    var call1 = onChange.mock.calls[0];
-    expect(call1[0]).toValueEqual(Immutable.fromJS({a:{b:{c:2}}}));
-    expect(call1[1]).toBe(data);
-    expect(call1[2]).toEqual(['a', 'b', 'c']);
-
-    var newestDeepCursor = newDeepCursor.update(x => x + 1);
-    expect(newestDeepCursor.deref()).toBe(3);
-    var call2 = onChange.mock.calls[1];
-    expect(call2[0]).toValueEqual(Immutable.fromJS({a:{b:{c:3}}}));
-    expect(call2[1]).toValueEqual(Immutable.fromJS({a:{b:{c:2}}}));
-    expect(call2[2]).toEqual(['a', 'b', 'c']);
-
-    // meanwhile, data is still immutable:
-    expect(data.toJS()).toEqual(json);
-
-    // as is the original cursor.
-    expect(deepCursor.deref()).toBe(1);
-    var otherNewDeepCursor = deepCursor.update(x => x + 10);
-    expect(otherNewDeepCursor.deref()).toBe(11);
-    var call3 = onChange.mock.calls[2];
-    expect(call3[0]).toValueEqual(Immutable.fromJS({a:{b:{c:11}}}));
-    expect(call3[1]).toBe(data);
-    expect(call3[2]).toEqual(['a', 'b', 'c']);
-
-    // and update has been called exactly thrice.
-    expect(onChange.mock.calls.length).toBe(3);
-  });
-
-  it('updates with the return value of onChange', () => {
-    var onChange = jest.genMockFunction();
-
-    var data = Immutable.fromJS(json);
-    var deepCursor = Cursor.from(data, ['a', 'b', 'c'], onChange);
-
-    onChange.mockReturnValueOnce(undefined);
-    // onChange returning undefined has no effect
-    var newCursor = deepCursor.update(x => x + 1);
-    expect(newCursor.deref()).toBe(2);
-    var call1 = onChange.mock.calls[0];
-    expect(call1[0]).toValueEqual(Immutable.fromJS({a:{b:{c:2}}}));
-    expect(call1[1]).toBe(data);
-    expect(call1[2]).toEqual(['a', 'b', 'c']);
-
-    onChange.mockReturnValueOnce(Immutable.fromJS({a:{b:{c:11}}}));
-    // onChange returning something else has an effect
-    newCursor = newCursor.update(x => 999);
-    expect(newCursor.deref()).toBe(11);
-    var call2 = onChange.mock.calls[1];
-    expect(call2[0]).toValueEqual(Immutable.fromJS({a:{b:{c:999}}}));
-    expect(call2[1]).toValueEqual(Immutable.fromJS({a:{b:{c:2}}}));
-    expect(call2[2]).toEqual(['a', 'b', 'c']);
-
-    // and update has been called exactly twice
-    expect(onChange.mock.calls.length).toBe(2);
-  });
-
-  it('has map API for update shorthand', () => {
-    var onChange = jest.genMockFunction();
-
-    var data = Immutable.fromJS(json);
-    var aCursor = Cursor.from(data, 'a', onChange);
-    var bCursor = aCursor.cursor('b');
-    var cCursor = bCursor.cursor('c');
-
-    expect(bCursor.set('c', 10).deref()).toValueEqual(
-      Immutable.fromJS({ c: 10 })
-    );
-
-    var call1 = onChange.mock.calls[0];
-    expect(call1[0]).toValueEqual(Immutable.fromJS({a:{b:{c:10}}}));
-    expect(call1[1]).toBe(data);
-    expect(call1[2]).toEqual(['a', 'b', 'c']);
-  });
-
-  it('creates maps as necessary', () => {
-    var data = Immutable.Map();
-    var cursor = Cursor.from(data, ['a', 'b', 'c']);
-    expect(cursor.deref()).toBe(undefined);
-    cursor = cursor.set('d', 3);
-    expect(cursor.deref()).toValueEqual(Immutable.Map({d: 3}));
-  });
-
-  it('can set undefined', () => {
-    var data = Immutable.Map();
-    var cursor = Cursor.from(data, ['a', 'b', 'c']);
-    expect(cursor.deref()).toBe(undefined);
-    cursor = cursor.set('d', undefined);
-    expect(cursor.toJS()).toEqual({d: undefined});
-  });
-
-  it('has the sequence API', () => {
-    var data = Immutable.Map({a: 1, b: 2, c: 3});
-    var cursor = Cursor.from(data);
-    expect(cursor.map((x: number) => x * x)).toValueEqual(Immutable.Map({a: 1, b: 4, c: 9}));
-  });
-
-  it('can push values on a List', () => {
-    var onChange = jest.genMockFunction();
-    var data = Immutable.fromJS({a: {b: [0, 1, 2]}});
-    var cursor = Cursor.from(data, ['a', 'b'], onChange);
-
-    expect(cursor.push(3,4)).toValueEqual(Immutable.List([0, 1, 2, 3, 4]));
-
-    var call = onChange.mock.calls[0];
-    expect(call[0]).toValueEqual(Immutable.fromJS({a: {b: [0, 1, 2, 3, 4]}}));
-    expect(call[1]).toBe(data);
-    expect(call[2]).toEqual(['a', 'b']);
-  });
-
-  it('can pop values of a List', () => {
-    var onChange = jest.genMockFunction();
-    var data = Immutable.fromJS({a: {b: [0, 1, 2]}});
-    var cursor = Cursor.from(data, ['a', 'b'], onChange);
-
-    expect(cursor.pop()).toValueEqual(Immutable.List([0, 1]));
-
-    var call = onChange.mock.calls[0];
-    expect(call[0]).toValueEqual(Immutable.fromJS({a: {b: [0, 1]}}));
-    expect(call[1]).toBe(data);
-    expect(call[2]).toEqual(['a', 'b']);
-  });
-
-  it('can unshift values on a List', () => {
-    var onChange = jest.genMockFunction();
-    var data = Immutable.fromJS({a: {b: [0, 1, 2]}});
-    var cursor = Cursor.from(data, ['a', 'b'], onChange);
-
-    expect(cursor.unshift(-2, -1)).toValueEqual(Immutable.List([-2, -1, 0, 1, 2]));
-
-    var call = onChange.mock.calls[0];
-    expect(call[0]).toValueEqual(Immutable.fromJS({a: {b: [-2, -1, 0, 1, 2]}}));
-    expect(call[1]).toBe(data);
-    expect(call[2]).toEqual(['a', 'b']);
-  });
-
-  it('can shift values of a List', () => {
-    var onChange = jest.genMockFunction();
-    var data = Immutable.fromJS({a: {b: [0, 1, 2]}});
-    var cursor = Cursor.from(data, ['a', 'b'], onChange);
-
-    expect(cursor.shift()).toValueEqual(Immutable.List([1, 2]));
-
-    var call = onChange.mock.calls[0];
-    expect(call[0]).toValueEqual(Immutable.fromJS({a: {b: [1, 2]}}));
-    expect(call[1]).toBe(data);
-    expect(call[2]).toEqual(['a', 'b']);
-  });
-
-
-  it('returns wrapped values for sequence API', () => {
-    var data = Immutable.fromJS({a: {v: 1}, b: {v: 2}, c: {v: 3}});
-    var onChange = jest.genMockFunction();
-    var cursor = Cursor.from(data, onChange);
-
-    var found = cursor.find(map => map.get('v') === 2);
-    expect(typeof found.deref).toBe('function'); // is a cursor!
-    found = found.set('v', 20);
-
-    var call = onChange.mock.calls[0];
-    expect(call[0]).toValueEqual(Immutable.fromJS({a: {v: 1}, b: {v: 20}, c: {v: 3}}));
-    expect(call[1]).toBe(data);
-    expect(call[2]).toEqual(['b', 'v']);
-  });
-
-  it('returns wrapped values for iteration API', () => {
-    var jsData = [{val: 0}, {val: 1}, {val: 2}];
-    var data = Immutable.fromJS(jsData);
-    var cursor = Cursor.from(data);
-    cursor.forEach(function (c, i) {
-      expect(typeof c.deref).toBe('function'); // is a cursor!
-      expect(c.get('val')).toBe(i);
-    });
-  });
-
-  it('can map over values to get subcursors', () => {
-    var data = Immutable.fromJS({a: {v: 1}, b: {v: 2}, c: {v: 3}});
-    var cursor = Cursor.from(data);
-
-    var mapped = cursor.map(val => {
-      expect(typeof val.deref).toBe('function'); // mapped values are cursors.
-      return val;
-    }).toMap();
-    // Mapped is not a cursor, but it is a sequence of cursors.
-    expect(typeof (<any>mapped).deref).not.toBe('function');
-    expect(typeof (<any>mapped.get('a')).deref).toBe('function');
-
-    // Same for indexed cursors
-    var data2 = Immutable.fromJS({x: [{v: 1}, {v: 2}, {v: 3}]});
-    var cursor2 = Cursor.from(data2);
-
-    var mapped2 = cursor2.get('x').map(val => {
-      expect(typeof val.deref).toBe('function'); // mapped values are cursors.
-      return val;
-    }).toList();
-    // Mapped is not a cursor, but it is a sequence of cursors.
-    expect(typeof mapped2.deref).not.toBe('function');
-    expect(typeof mapped2.get(0).deref).toBe('function');
-  });
-
-  it('can have mutations apply with a single callback', () => {
-    var onChange = jest.genMockFunction();
-    var data = Immutable.fromJS({'a': 1});
-
-    var c1 = Cursor.from(data, onChange);
-    var c2 = c1.withMutations(m => m.set('b', 2).set('c', 3).set('d', 4));
-
-    expect(c1.deref().toObject()).toEqual({'a': 1});
-    expect(c2.deref().toObject()).toEqual({'a': 1, 'b': 2, 'c': 3, 'd': 4});
-    expect(onChange.mock.calls.length).toBe(1);
-  });
-
-  it('can use withMutations on an unfulfilled cursor', () => {
-    var onChange = jest.genMockFunction();
-    var data = Immutable.fromJS({});
-
-    var c1 = Cursor.from(data, ['a', 'b', 'c'], onChange);
-    var c2 = c1.withMutations(m => m.set('x', 1).set('y', 2).set('z', 3));
-
-    expect(c1.deref()).toEqual(undefined);
-    expect(c2.deref()).toValueEqual(Immutable.fromJS(
-      { x: 1, y: 2, z: 3 }
-    ));
-    expect(onChange.mock.calls.length).toBe(1);
-  });
-
-  it('maintains indexed sequences', () => {
-    var data = Immutable.fromJS([]);
-    var c = Cursor.from(data);
-    expect(c.toJS()).toEqual([]);
-  });
-
-  it('properly acts as an iterable', () => {
-    var data = Immutable.fromJS({key: {val: 1}});
-    var c = Cursor.from(data).values();
-    var c1 = c.next().value.get('val');
-    expect(c1).toBe(1);
-  });
-
-  it('can update deeply', () => {
-    var onChange = jest.genMockFunction();
-    var data = Immutable.fromJS({a:{b:{c:1}}});
-    var c = Cursor.from(data, ['a'], onChange);
-    var c1 = c.updateIn(['b', 'c'], x => x * 10);
-    expect(c1.getIn(['b', 'c'])).toBe(10);
-
-    var call = onChange.mock.calls[0];
-    expect(call[0]).toValueEqual(Immutable.fromJS({a:{b:{c:10}}}));
-    expect(call[1]).toBe(data);
-    expect(call[2]).toEqual(['a', 'b', 'c']);
-  });
-
-  it('can set deeply', () => {
-    var onChange = jest.genMockFunction();
-    var data = Immutable.fromJS({a:{b:{c:1}}});
-    var c = Cursor.from(data, ['a'], onChange);
-    var c1 = c.setIn(['b', 'c'], 10);
-    expect(c1.getIn(['b', 'c'])).toBe(10);
-
-    var call = onChange.mock.calls[0];
-    expect(call[0]).toValueEqual(Immutable.fromJS({a:{b:{c:10}}}));
-    expect(call[1]).toBe(data);
-    expect(call[2]).toEqual(['a', 'b', 'c']);
-  });
-
-  it('can get Record value as a property', () => {
-    var User = Immutable.Record({ name: 'John' });
-    var users = Immutable.List.of(new User());
-    var data = Immutable.Map({'users': users});
-    var cursor = Cursor.from(data, ['users']);
-    expect(cursor.first().name).toBe('John');
-  });
-
-  it('can set value of a cursor directly', () => {
-    var onChange = jest.genMockFunction();
-    var data = Immutable.fromJS({a:1});
-    var c = Cursor.from(data, ['a'], onChange);
-    var c1 = c.set(2);
-    expect(c1.deref()).toBe(2);
-
-    var call = onChange.mock.calls[0];
-    expect(call[0]).toValueEqual(Immutable.fromJS({a:2}));
-    expect(call[1]).toBe(data);
-    expect(call[2]).toEqual(['a']);
-  });
-
-  it('can set value of a cursor to undefined directly', () => {
-    var onChange = jest.genMockFunction();
-    var data = Immutable.fromJS({a:1});
-    var c = Cursor.from(data, ['a'], onChange);
-    var c1 = c.set(undefined);
-    expect(c1.deref()).toBe(undefined);
-
-    var call = onChange.mock.calls[0];
-    expect(call[0]).toValueEqual(Immutable.fromJS({a:undefined}));
-    expect(call[1]).toBe(data);
-    expect(call[2]).toEqual(['a']);
-  });
-
-});