Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Appearance settings

Commit e9d93c7

Browse filesBrowse files
leebyronleebyron
committed
Merge branch 'v3'
2 parents 4421faa + 24d2723 commit e9d93c7
Copy full SHA for e9d93c7

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.
Dismiss banner

62 files changed

+7231
-6701
lines changed

‎Gruntfile.js

Copy file name to clipboardExpand all lines: Gruntfile.js
-1Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,6 @@ module.exports = function(grunt) {
1414
asi: true,
1515
curly: false,
1616
eqeqeq: true,
17-
eqnull: true,
1817
esnext: true,
1918
expr: true,
2019
forin: true,

‎README.md

Copy file name to clipboardExpand all lines: README.md
+98-120Lines changed: 98 additions & 120 deletions
Large diffs are not rendered by default.

‎__tests__/ArraySequence.ts renamed to ‎__tests__/ArraySeq.ts

Copy file name to clipboardExpand all lines: __tests__/ArraySeq.ts
+22-22Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -7,33 +7,33 @@ import Immutable = require('immutable');
77
describe('ArraySequence', () => {
88

99
it('every is true when predicate is true for all entries', () => {
10-
expect(Immutable.Sequence([]).every(() => false)).toBe(true);
11-
expect(Immutable.Sequence([1,2,3]).every(v => v > 0)).toBe(true);
12-
expect(Immutable.Sequence([1,2,3]).every(v => v < 3)).toBe(false);
10+
expect(Immutable.Seq([]).every(() => false)).toBe(true);
11+
expect(Immutable.Seq([1,2,3]).every(v => v > 0)).toBe(true);
12+
expect(Immutable.Seq([1,2,3]).every(v => v < 3)).toBe(false);
1313
});
1414

1515
it('some is true when predicate is true for any entry', () => {
16-
expect(Immutable.Sequence([]).some(() => true)).toBe(false);
17-
expect(Immutable.Sequence([1,2,3]).some(v => v > 0)).toBe(true);
18-
expect(Immutable.Sequence([1,2,3]).some(v => v < 3)).toBe(true);
19-
expect(Immutable.Sequence([1,2,3]).some(v => v > 1)).toBe(true);
20-
expect(Immutable.Sequence([1,2,3]).some(v => v < 0)).toBe(false);
16+
expect(Immutable.Seq([]).some(() => true)).toBe(false);
17+
expect(Immutable.Seq([1,2,3]).some(v => v > 0)).toBe(true);
18+
expect(Immutable.Seq([1,2,3]).some(v => v < 3)).toBe(true);
19+
expect(Immutable.Seq([1,2,3]).some(v => v > 1)).toBe(true);
20+
expect(Immutable.Seq([1,2,3]).some(v => v < 0)).toBe(false);
2121
});
2222

2323
it('maps', () => {
24-
var i = Immutable.Sequence([1,2,3]);
24+
var i = Immutable.Seq([1,2,3]);
2525
var m = i.map(x => x + x).toObject();
2626
expect(m).toEqual([2,4,6]);
2727
});
2828

2929
it('reduces', () => {
30-
var i = Immutable.Sequence([1,2,3]);
30+
var i = Immutable.Seq([1,2,3]);
3131
var r = i.reduce<number>((r, x) => r + x);
3232
expect(r).toEqual(6);
3333
});
3434

3535
it('efficiently chains iteration methods', () => {
36-
var i = Immutable.Sequence('abcdefghijklmnopqrstuvwxyz'.split(''));
36+
var i = Immutable.Seq('abcdefghijklmnopqrstuvwxyz'.split(''));
3737
function studly(letter, index) {
3838
return index % 2 === 0 ? letter : letter.toUpperCase();
3939
}
@@ -42,7 +42,7 @@ describe('ArraySequence', () => {
4242
});
4343

4444
it('counts from the end of the sequence on negative index', () => {
45-
var i = Immutable.Sequence(1, 2, 3, 4, 5, 6, 7);
45+
var i = Immutable.Seq.of(1, 2, 3, 4, 5, 6, 7);
4646
expect(i.get(-1)).toBe(7);
4747
expect(i.get(-5)).toBe(3);
4848
expect(i.get(-9)).toBe(undefined);
@@ -52,23 +52,23 @@ describe('ArraySequence', () => {
5252
it('handles trailing holes', () => {
5353
var a = [1,2,3];
5454
a.length = 10;
55-
var seq = Immutable.Sequence(a);
56-
expect(seq.length).toBe(10);
55+
var seq = Immutable.Seq(a);
56+
expect(seq.size).toBe(10);
5757
expect(seq.toArray().length).toBe(10);
58-
expect(seq.map(x => x*x).length).toBe(10);
58+
expect(seq.map(x => x*x).size).toBe(10);
5959
expect(seq.map(x => x*x).toArray().length).toBe(10);
6060
expect(seq.skip(2).toArray().length).toBe(8);
6161
expect(seq.take(2).toArray().length).toBe(2);
6262
expect(seq.take(5).toArray().length).toBe(5);
6363
expect(seq.filter(x => x%2==1).toArray().length).toBe(2);
64-
expect(seq.flip().length).toBe(10);
65-
expect(seq.flip().flip().length).toBe(10);
66-
expect(seq.flip().flip().toArray().length).toBe(10);
64+
expect(seq.toKeyedSeq().flip().size).toBe(10);
65+
expect(seq.toKeyedSeq().flip().flip().size).toBe(10);
66+
expect(seq.toKeyedSeq().flip().flip().toArray().length).toBe(10);
6767
});
6868

6969
it('can be iterated', () => {
7070
var a = [1,2,3];
71-
var seq = Immutable.Sequence(a);
71+
var seq = Immutable.Seq(a);
7272
var entries = seq.entries();
7373
expect(entries.next()).toEqual({ value: [0, 1], done: false });
7474
expect(entries.next()).toEqual({ value: [1, 2], done: false });
@@ -77,10 +77,10 @@ describe('ArraySequence', () => {
7777
});
7878

7979
it('cannot be mutated after calling toArray', () => {
80-
var seq = Immutable.Sequence(['A', 'B', 'C']);
80+
var seq = Immutable.Seq(['A', 'B', 'C']);
8181

82-
var firstReverse = Immutable.Sequence(seq.toArray().reverse());
83-
var secondReverse = Immutable.Sequence(seq.toArray().reverse());
82+
var firstReverse = Immutable.Seq(seq.toArray().reverse());
83+
var secondReverse = Immutable.Seq(seq.toArray().reverse());
8484

8585
expect(firstReverse.get(0)).toEqual('C');
8686
expect(secondReverse.get(0)).toEqual('C');

‎__tests__/Conversion.ts

Copy file name to clipboardExpand all lines: __tests__/Conversion.ts
+8-8Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ jest.autoMockOff();
66
import Immutable = require('immutable');
77
import Map = Immutable.Map;
88
import OrderedMap = Immutable.OrderedMap;
9-
import Vector = Immutable.Vector;
9+
import List = Immutable.List;
1010

1111
declare function expect(val: any): ExpectWithIs;
1212

@@ -50,7 +50,7 @@ describe('Conversion', () => {
5050
var Point = Immutable.Record({x:0, y:0}, 'Point');
5151

5252
var immutableData = Map({
53-
deepList: Vector(
53+
deepList: List.of(
5454
Map({
5555
position: "first"
5656
}),
@@ -67,11 +67,11 @@ describe('Conversion', () => {
6767
}),
6868
point: Map({x: 10, y: 20}),
6969
string: "Hello",
70-
list: Vector(1, 2, 3)
70+
list: List.of(1, 2, 3)
7171
});
7272

7373
var immutableOrderedData = OrderedMap({
74-
deepList: Vector(
74+
deepList: List.of(
7575
OrderedMap({
7676
position: "first"
7777
}),
@@ -88,11 +88,11 @@ describe('Conversion', () => {
8888
}),
8989
point: new Point({x: 10, y: 20}),
9090
string: "Hello",
91-
list: Vector(1, 2, 3)
91+
list: List.of(1, 2, 3)
9292
});
9393

9494
var immutableOrderedDataString = 'OrderedMap { ' +
95-
'deepList: Vector [ '+
95+
'deepList: List [ '+
9696
'OrderedMap { '+
9797
'position: "first"'+
9898
' }, ' +
@@ -109,7 +109,7 @@ describe('Conversion', () => {
109109
' }, '+
110110
'point: Point { x: 10, y: 20 }, '+
111111
'string: "Hello", '+
112-
'list: Vector [ 1, 2, 3 ]'+
112+
'list: List [ 1, 2, 3 ]'+
113113
' }';
114114

115115
it('Converts deep JS to deep immutable sequences', () => {
@@ -121,7 +121,7 @@ describe('Conversion', () => {
121121
if (key === 'point') {
122122
return new Point(sequence);
123123
}
124-
return Array.isArray(this[key]) ? sequence.toVector() : sequence.toOrderedMap();
124+
return Array.isArray(this[key]) ? sequence.toList() : sequence.toOrderedMap();
125125
});
126126
expect(seq).is(immutableOrderedData);
127127
expect(seq.toString()).is(immutableOrderedDataString);

‎__tests__/Equality.ts

Copy file name to clipboardExpand all lines: __tests__/Equality.ts
+15-15Lines changed: 15 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -52,32 +52,32 @@ describe('Equality', () => {
5252
});
5353

5454
it('compares sequences', () => {
55-
var arraySeq = Immutable.Sequence(1,2,3);
56-
var arraySeq2 = Immutable.Sequence([1,2,3]);
55+
var arraySeq = Immutable.Seq.of(1,2,3);
56+
var arraySeq2 = Immutable.Seq([1,2,3]);
5757
expectIs(arraySeq, arraySeq);
58-
expectIs(arraySeq, Immutable.Sequence(1,2,3));
58+
expectIs(arraySeq, Immutable.Seq.of(1,2,3));
5959
expectIs(arraySeq2, arraySeq2);
60-
expectIs(arraySeq2, Immutable.Sequence([1,2,3]));
60+
expectIs(arraySeq2, Immutable.Seq([1,2,3]));
6161
expectIsNot(arraySeq, [1,2,3]);
6262
expectIsNot(arraySeq2, [1,2,3]);
6363
expectIs(arraySeq, arraySeq2);
6464
expectIs(arraySeq, arraySeq.map(x => x));
6565
expectIs(arraySeq2, arraySeq2.map(x => x));
6666
});
6767

68-
it('compares vectors', () => {
69-
var vector = Immutable.Vector(1,2,3);
70-
expectIs(vector, vector);
71-
expectIsNot(vector, [1,2,3]);
68+
it('compares lists', () => {
69+
var list = Immutable.List.of(1,2,3);
70+
expectIs(list, list);
71+
expectIsNot(list, [1,2,3]);
7272

73-
expectIs(vector, Immutable.Sequence(1,2,3));
74-
expectIs(vector, Immutable.Vector(1,2,3));
73+
expectIs(list, Immutable.Seq.of(1,2,3));
74+
expectIs(list, Immutable.List.of(1,2,3));
7575

76-
var vectorLonger = vector.push(4);
77-
expectIsNot(vector, vectorLonger);
78-
var vectorShorter = vectorLonger.pop();
79-
expect(vector === vectorShorter).toBe(false);
80-
expectIs(vector, vectorShorter);
76+
var listLonger = list.push(4);
77+
expectIsNot(list, listLonger);
78+
var listShorter = listLonger.pop();
79+
expect(list === listShorter).toBe(false);
80+
expectIs(list, listShorter);
8181
});
8282

8383
// TODO: more tests

‎__tests__/IndexedSequence.ts renamed to ‎__tests__/IndexedSeq.ts

Copy file name to clipboardExpand all lines: __tests__/IndexedSeq.ts
+2-2Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ import Immutable = require('immutable');
1010
describe('IndexedSequence', () => {
1111

1212
it('maintains skipped offset', () => {
13-
var seq = Immutable.Sequence(['A', 'B', 'C', 'D', 'E']);
13+
var seq = Immutable.Seq(['A', 'B', 'C', 'D', 'E']);
1414

1515
// This is what we expect for IndexedSequences
1616
var operated = seq.skip(1);
@@ -25,7 +25,7 @@ describe('IndexedSequence', () => {
2525
});
2626

2727
it('reverses correctly', () => {
28-
var seq = Immutable.Sequence.from(['A', 'B', 'C', 'D', 'E']);
28+
var seq = Immutable.Seq(['A', 'B', 'C', 'D', 'E']);
2929

3030
// This is what we expect for IndexedSequences
3131
var operated = seq.reverse();

‎__tests__/IterableSequence.ts renamed to ‎__tests__/IterableSeq.ts

Copy file name to clipboardExpand all lines: __tests__/IterableSeq.ts
+13-11Lines changed: 13 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -9,21 +9,21 @@ describe('IterableSequence', () => {
99

1010
it('creates a sequence from an iterable', () => {
1111
var i = new SimpleIterable();
12-
var s = Immutable.Sequence(i);
12+
var s = Immutable.Seq(i);
1313
expect(s.take(5).toArray()).toEqual([ 0,1,2,3,4 ]);
1414
})
1515

1616
it('is stable', () => {
1717
var i = new SimpleIterable();
18-
var s = Immutable.Sequence(i);
18+
var s = Immutable.Seq(i);
1919
expect(s.take(5).toArray()).toEqual([ 0,1,2,3,4 ]);
2020
expect(s.take(5).toArray()).toEqual([ 0,1,2,3,4 ]);
2121
expect(s.take(5).toArray()).toEqual([ 0,1,2,3,4 ]);
2222
})
2323

2424
it('counts iterations', () => {
2525
var i = new SimpleIterable(10);
26-
var s = Immutable.Sequence(i);
26+
var s = Immutable.Seq(i);
2727
expect(s.forEach(x => x)).toEqual(10);
2828
expect(s.take(5).forEach(x => x)).toEqual(5);
2929
expect(s.forEach(x => x < 3)).toEqual(4);
@@ -32,7 +32,7 @@ describe('IterableSequence', () => {
3232
it('creates a new iterator on every operations', () => {
3333
var mockFn = jest.genMockFunction();
3434
var i = new SimpleIterable(3, mockFn);
35-
var s = Immutable.Sequence(i);
35+
var s = Immutable.Seq(i);
3636
expect(s.toArray()).toEqual([ 0,1,2 ]);
3737
expect(mockFn.mock.calls).toEqual([[0],[1],[2]]);
3838
// The iterator is recreated for the second time.
@@ -43,7 +43,7 @@ describe('IterableSequence', () => {
4343
it('can be iterated', () => {
4444
var mockFn = jest.genMockFunction();
4545
var i = new SimpleIterable(3, mockFn);
46-
var seq = Immutable.Sequence(i);
46+
var seq = Immutable.Seq(i);
4747
var entries = seq.entries();
4848
expect(entries.next()).toEqual({ value: [0, 0], done: false });
4949
// The iteration is lazy
@@ -64,7 +64,9 @@ describe('IterableSequence', () => {
6464
it('can be mapped and filtered', () => {
6565
var mockFn = jest.genMockFunction();
6666
var i = new SimpleIterable(undefined, mockFn); // infinite
67-
var seq = Immutable.Sequence(i).filter(x => x % 2 === 1).map(x => x * x);
67+
var seq = Immutable.Seq<number, number>(i)
68+
.filter(x => x % 2 === 1)
69+
.map(x => x * x);
6870
var entries = seq.entries();
6971
expect(entries.next()).toEqual({ value: [0, 1], done: false });
7072
expect(entries.next()).toEqual({ value: [1, 9], done: false });
@@ -76,21 +78,21 @@ describe('IterableSequence', () => {
7678

7779
it('creates a sequence from a raw iterable', () => {
7880
var i = new SimpleIterable(10);
79-
var s = Immutable.Sequence(i['@@iterator']());
81+
var s = Immutable.Seq(i['@@iterator']());
8082
expect(s.take(5).toArray()).toEqual([ 0,1,2,3,4 ]);
8183
})
8284

8385
it('is stable', () => {
8486
var i = new SimpleIterable(10);
85-
var s = Immutable.Sequence(i['@@iterator']());
87+
var s = Immutable.Seq(i['@@iterator']());
8688
expect(s.take(5).toArray()).toEqual([ 0,1,2,3,4 ]);
8789
expect(s.take(5).toArray()).toEqual([ 0,1,2,3,4 ]);
8890
expect(s.take(5).toArray()).toEqual([ 0,1,2,3,4 ]);
8991
})
9092

9193
it('counts iterations', () => {
9294
var i = new SimpleIterable(10);
93-
var s = Immutable.Sequence(i['@@iterator']());
95+
var s = Immutable.Seq(i['@@iterator']());
9496
expect(s.forEach(x => x)).toEqual(10);
9597
expect(s.take(5).forEach(x => x)).toEqual(5);
9698
expect(s.forEach(x => x < 3)).toEqual(4);
@@ -99,7 +101,7 @@ describe('IterableSequence', () => {
99101
it('memoizes the iterator', () => {
100102
var mockFn = jest.genMockFunction();
101103
var i = new SimpleIterable(10, mockFn);
102-
var s = Immutable.Sequence(i['@@iterator']());
104+
var s = Immutable.Seq(i['@@iterator']());
103105
expect(s.take(3).toArray()).toEqual([ 0,1,2 ]);
104106
expect(mockFn.mock.calls).toEqual([[0],[1],[2]]);
105107

@@ -115,7 +117,7 @@ describe('IterableSequence', () => {
115117
it('can be iterated', () => {
116118
var mockFn = jest.genMockFunction();
117119
var i = new SimpleIterable(3, mockFn);
118-
var seq = Immutable.Sequence(i['@@iterator']());
120+
var seq = Immutable.Seq(i['@@iterator']());
119121
var entries = seq.entries();
120122
expect(entries.next()).toEqual({ value: [0, 0], done: false });
121123
// The iteration is lazy

‎__tests__/KeyedIndexedSequence.ts renamed to ‎__tests__/KeyedSeq.ts

Copy file name to clipboardExpand all lines: __tests__/KeyedSeq.ts
+2-2Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7,10 +7,10 @@ jasmineCheck.install();
77

88
import Immutable = require('immutable');
99

10-
describe('KeyedIndexedSequence', () => {
10+
describe('KeyedSeq', () => {
1111

1212
check.it('is equivalent', [gen.array(gen.int)], (ints) => {
13-
var seq = Immutable.Sequence(ints);
13+
var seq = Immutable.Seq(ints);
1414
var keyed = seq.toKeyedSeq();
1515
expect(seq.equals(keyed)).toBe(true);
1616
});

0 commit comments

Comments
0 (0)
Morty Proxy This is a proxified and sanitized view of the page, visit original site.