10 |
85 | );
86 | }
87 |
88 | // export type ParamTypeMap = { [param: string]: Type };
89 |
90 | // function getParamTypeMap(
91 | // interfaceDef: InterfaceDefinition | undefined,
92 | // member: MemberDefinition
93 | // ): ParamTypeMap | undefined {
94 | // if (!member.inherited || !interfaceDef?.typeParamsMap) return;
95 | // const defining = member.inherited.split('#')[0] + '>';
96 | // const paramTypeMap: ParamTypeMap = {};
97 | // // Filter typeParamsMap down to only those relevant to the defining interface.
98 | // for (const [path, type] of Object.entries(interfaceDef.typeParamsMap)) {
99 | // if (path.startsWith(defining)) {
100 | // paramTypeMap[path.slice(defining.length)] = type;
101 | // }
102 | // }
103 | // return paramTypeMap;
104 | // }
105 |
--------------------------------------------------------------------------------
/__tests__/flatten.ts:
--------------------------------------------------------------------------------
1 | import { Collection, fromJS, List, Range, Seq } from 'immutable';
2 |
3 | import * as jasmineCheck from 'jasmine-check';
4 | jasmineCheck.install();
5 |
6 | describe('flatten', () => {
7 | it('flattens sequences one level deep', () => {
8 | const nested = fromJS([
9 | [1, 2],
10 | [3, 4],
11 | [5, 6],
12 | ]);
13 | const flat = nested.flatten();
14 | expect(flat.toJS()).toEqual([1, 2, 3, 4, 5, 6]);
15 | });
16 |
17 | it('flattening a List returns a List', () => {
18 | const nested = fromJS([[1], 2, 3, [4, 5, 6]]);
19 | const flat = nested.flatten();
20 | expect(flat.toString()).toEqual('List [ 1, 2, 3, 4, 5, 6 ]');
21 | });
22 |
23 | it('gives the correct iteration count', () => {
24 | const nested = fromJS([
25 | [1, 2, 3],
26 | [4, 5, 6],
27 | ]);
28 | const flat = nested.flatten();
29 | expect(flat.forEach((x: any) => x < 4)).toEqual(4);
30 | });
31 |
32 | type SeqType = number | Array11 | {member.label} 12 |
13 |
14 | {member.doc && (
15 |
36 |
45 | )}
46 | {member.overrides && (
47 |
48 |
57 | )}
58 | {member.doc?.notes.map((note, i) => (
59 |
60 |
69 | ))}
70 | {member.doc?.description && (
71 |
72 |
73 | {member.doc.description.slice(0, 5) === '
82 | )}
83 |
84 |
22 |
24 | ) : (
25 |
26 | {member.signatures.map((callSig, i) => (
27 |
28 |
31 | ))}
32 |
33 | )}
34 | {member.inherited && (
35 | Inherited from
37 |
38 |
39 |
40 | {member.inherited.interface}#{member.inherited.label}
41 |
42 |
43 |
44 | Overrides
49 |
50 |
51 |
52 | {member.overrides.interface}#{member.overrides.label}
53 |
54 |
55 |
56 | {note.name}
61 | {note.name === 'alias' ? ( 62 |
63 |
65 | ) : (
66 |
73 | {member.doc.description.slice(0, 5) === '
77 |
${lhsString}
117 | ${comparison}
118 | ${rhsString}
119 | `); 120 | } 121 | 122 | function equal(lhs: any, rhs: any) { 123 | return message(lhs, rhs, true, false); 124 | } 125 | 126 | function notEqual(lhs: any, rhs: any) { 127 | return message(lhs, rhs, false, false); 128 | } 129 | 130 | function strictEqual(lhs: any, rhs: any) { 131 | return message(lhs, rhs, true, true); 132 | } 133 | 134 | function notStrictEqual(lhs: any, rhs: any) { 135 | return message(lhs, rhs, false, true); 136 | } 137 | 138 | return { equal, notEqual, strictEqual, notStrictEqual }; 139 | } 140 | -------------------------------------------------------------------------------- /.github/workflows/ci.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | 3 | on: 4 | push: 5 | branches: 6 | - main 7 | pull_request: 8 | branches: 9 | - main 10 | 11 | jobs: 12 | lint: 13 | name: 'Lint' 14 | runs-on: ubuntu-latest 15 | steps: 16 | - uses: actions/checkout@v2 17 | - uses: actions/setup-node@v2 18 | with: 19 | node-version: '16' 20 | - uses: actions/cache@v2 21 | with: 22 | path: ~/.npm 23 | key: ${{ runner.OS }}-node-${{ hashFiles('**/package-lock.json') }} 24 | restore-keys: ${{ runner.OS }}-node- 25 | - run: npm ci 26 | - run: npm run lint 27 | - run: npm run check-git-clean 28 | 29 | type-check: 30 | name: 'Type Check' 31 | runs-on: ubuntu-latest 32 | steps: 33 | - uses: actions/checkout@v2 34 | - uses: actions/setup-node@v2 35 | with: 36 | node-version: '16' 37 | - uses: actions/cache@v2 38 | with: 39 | path: ~/.npm 40 | key: ${{ runner.OS }}-node-${{ hashFiles('**/package-lock.json') }} 41 | restore-keys: ${{ runner.OS }}-node- 42 | - uses: actions/cache@v2 43 | with: 44 | path: ~/.dts 45 | key: ${{ runner.OS }}-dts-${{ hashFiles('**/package-lock.json') }} 46 | restore-keys: ${{ runner.OS }}-dts- 47 | - run: npm ci 48 | - run: npm run type-check 49 | - run: npm run check-git-clean 50 | 51 | unit-test: 52 | name: 'Build & Unit Test' 53 | runs-on: ubuntu-latest 54 | steps: 55 | - uses: actions/checkout@v2 56 | - uses: actions/setup-node@v2 57 | with: 58 | node-version: '16' 59 | - uses: actions/cache@v2 60 | with: 61 | path: ~/.npm 62 | key: ${{ runner.OS }}-node-${{ hashFiles('**/package-lock.json') }} 63 | restore-keys: ${{ runner.OS }}-node- 64 | - run: npm ci 65 | - run: npm run build 66 | - run: npm run unit-test 67 | - run: npm run check-git-clean 68 | 69 | website: 70 | name: 'Build Website' 71 | runs-on: ubuntu-latest 72 | steps: 73 | - uses: actions/checkout@v2 74 | with: 75 | fetch-depth: 0 76 | - uses: actions/setup-node@v2 77 | with: 78 | node-version: '16' 79 | - uses: actions/cache@v2 80 | with: 81 | path: ~/.npm 82 | key: ${{ runner.OS }}-node-${{ hashFiles('**/package-lock.json') }} 83 | restore-keys: ${{ runner.OS }}-node- 84 | - run: npm ci 85 | - run: npm run website:build 86 | - run: npm run check-git-clean 87 | 88 | publish: 89 | name: 'Publish' 90 | needs: [lint, type-check, unit-test, website] 91 | if: github.ref == 'refs/heads/main' 92 | runs-on: ubuntu-latest 93 | steps: 94 | - uses: actions/checkout@v2 95 | with: 96 | fetch-depth: 0 97 | - uses: actions/setup-node@v2 98 | with: 99 | node-version: '16' 100 | - uses: actions/cache@v2 101 | with: 102 | path: ~/.npm 103 | key: ${{ runner.OS }}-node-${{ hashFiles('**/package-lock.json') }} 104 | restore-keys: ${{ runner.OS }}-node- 105 | - run: npm ci 106 | - run: npm run build 107 | - run: npm run website:build 108 | - name: Push NPM Branch 109 | if: github.ref == 'refs/heads/main' 110 | uses: peaceiris/actions-gh-pages@v3 111 | with: 112 | enable_jekyll: true 113 | github_token: ${{ secrets.GITHUB_TOKEN }} 114 | publish_dir: ./npm 115 | publish_branch: npm 116 | user_name: 'github-actions[bot]' 117 | user_email: 'github-actions[bot]@users.noreply.github.com' 118 | - name: Publish Docs 119 | if: github.ref == 'refs/heads/main' 120 | uses: peaceiris/actions-gh-pages@v3 121 | with: 122 | github_token: ${{ secrets.GITHUB_TOKEN }} 123 | publish_dir: ./website/out 124 | cname: immutable-js.com 125 | user_name: 'github-actions[bot]' 126 | user_email: 'github-actions[bot]@users.noreply.github.com' 127 | -------------------------------------------------------------------------------- /__tests__/getIn.ts: -------------------------------------------------------------------------------- 1 | import { fromJS, getIn, List, Map } from 'immutable'; 2 | 3 | describe('getIn', () => { 4 | it('deep get', () => { 5 | const m = fromJS({ a: { b: { c: 10 } } }); 6 | expect(m.getIn(['a', 'b', 'c'])).toEqual(10); 7 | expect(getIn(m, ['a', 'b', 'c'])).toEqual(10); 8 | }); 9 | 10 | it('deep get with list as keyPath', () => { 11 | const m = fromJS({ a: { b: { c: 10 } } }); 12 | expect(m.getIn(fromJS(['a', 'b', 'c']))).toEqual(10); 13 | expect(getIn(m, fromJS(['a', 'b', 'c']))).toEqual(10); 14 | }); 15 | 16 | it('deep get throws without list or array-like', () => { 17 | // @ts-expect-error 18 | expect(() => Map().getIn(undefined)).toThrow( 19 | 'Invalid keyPath: expected Ordered Collection or Array: undefined' 20 | ); 21 | // @ts-expect-error 22 | expect(() => Map().getIn({ a: 1, b: 2 })).toThrow( 23 | 'Invalid keyPath: expected Ordered Collection or Array: [object Object]' 24 | ); 25 | // TODO: should expect error 26 | expect(() => Map().getIn('abc')).toThrow( 27 | 'Invalid keyPath: expected Ordered Collection or Array: abc' 28 | ); 29 | // TODO: should expect error 30 | expect(() => getIn(Map(), 'abc')).toThrow( 31 | 'Invalid keyPath: expected Ordered Collection or Array: abc' 32 | ); 33 | }); 34 | 35 | it('deep get returns not found if path does not match', () => { 36 | const m = fromJS({ a: { b: { c: 10 } } }); 37 | expect(m.getIn(['a', 'b', 'z'])).toEqual(undefined); 38 | expect(m.getIn(['a', 'b', 'z'], 123)).toEqual(123); 39 | expect(m.getIn(['a', 'y', 'z'])).toEqual(undefined); 40 | expect(m.getIn(['a', 'y', 'z'], 123)).toEqual(123); 41 | expect(getIn(m, ['a', 'y', 'z'])).toEqual(undefined); 42 | expect(getIn(m, ['a', 'y', 'z'], 123)).toEqual(123); 43 | }); 44 | 45 | it('does not use notSetValue when path does exist but value is nullable', () => { 46 | const m = fromJS({ a: { b: { c: null, d: undefined } } }); 47 | expect(m.getIn(['a', 'b', 'c'])).toEqual(null); 48 | expect(m.getIn(['a', 'b', 'd'])).toEqual(undefined); 49 | expect(m.getIn(['a', 'b', 'c'], 123)).toEqual(null); 50 | expect(m.getIn(['a', 'b', 'd'], 123)).toEqual(undefined); 51 | expect(getIn(m, ['a', 'b', 'c'], 123)).toEqual(null); 52 | expect(getIn(m, ['a', 'b', 'd'], 123)).toEqual(undefined); 53 | }); 54 | 55 | it('deep get returns not found if path encounters non-data-structure', () => { 56 | const m = fromJS({ a: { b: { c: null, d: undefined } } }); 57 | expect(m.getIn(['a', 'b', 'c', 'x'])).toEqual(undefined); 58 | expect(m.getIn(['a', 'b', 'c', 'x'], 123)).toEqual(123); 59 | expect(m.getIn(['a', 'b', 'd', 'x'])).toEqual(undefined); 60 | expect(m.getIn(['a', 'b', 'd', 'x'], 123)).toEqual(123); 61 | expect(getIn(m, ['a', 'b', 'd', 'x'])).toEqual(undefined); 62 | expect(getIn(m, ['a', 'b', 'd', 'x'], 123)).toEqual(123); 63 | 64 | expect(getIn('a', ['length'])).toEqual(undefined); 65 | expect(getIn(new Date(), ['getDate'])).toEqual(undefined); 66 | }); 67 | 68 | it('gets in nested plain Objects and Arrays', () => { 69 | const m = List([{ key: ['item'] }]); 70 | expect(m.getIn([0, 'key', 0])).toEqual('item'); 71 | }); 72 | 73 | it('deep get returns not found if non-existing path in nested plain Object', () => { 74 | const deep = Map({ 75 | key: { regular: 'jsobj' }, 76 | list: List([Map({ num: 10 })]), 77 | }); 78 | expect(deep.getIn(['key', 'foo', 'item'])).toBe(undefined); 79 | expect(deep.getIn(['key', 'foo', 'item'], 'notSet')).toBe('notSet'); 80 | expect(deep.getIn(['list', 0, 'num', 'badKey'])).toBe(undefined); 81 | expect(deep.getIn(['list', 0, 'num', 'badKey'], 'notSet')).toBe('notSet'); 82 | }); 83 | 84 | it('gets in plain Objects and Arrays', () => { 85 | const m = [{ key: ['item'] }]; 86 | expect(getIn(m, [0, 'key', 0])).toEqual('item'); 87 | }); 88 | 89 | it('deep get returns not found if non-existing path in plain Object', () => { 90 | const deep = { key: { regular: 'jsobj' }, list: [{ num: 10 }] }; 91 | expect(getIn(deep, ['key', 'foo', 'item'])).toBe(undefined); 92 | expect(getIn(deep, ['key', 'foo', 'item'], 'notSet')).toBe('notSet'); 93 | expect(getIn(deep, ['list', 0, 'num', 'badKey'])).toBe(undefined); 94 | expect(getIn(deep, ['list', 0, 'num', 'badKey'], 'notSet')).toBe('notSet'); 95 | }); 96 | }); 97 | -------------------------------------------------------------------------------- /__tests__/zip.ts: -------------------------------------------------------------------------------- 1 | import { List, Range, Seq } from 'immutable'; 2 | 3 | import * as jasmineCheck from 'jasmine-check'; 4 | jasmineCheck.install(); 5 | 6 | describe('zip', () => { 7 | it('zips lists into a list of tuples', () => { 8 | expect( 9 | Seq([1, 2, 3]) 10 | .zip(Seq([4, 5, 6])) 11 | .toArray() 12 | ).toEqual([ 13 | [1, 4], 14 | [2, 5], 15 | [3, 6], 16 | ]); 17 | }); 18 | 19 | it('zip results can be converted to JS', () => { 20 | const l1 = List([List([1]), List([2]), List([3])]); 21 | const l2 = List([List([4]), List([5]), List([6])]); 22 | const zipped = l1.zip(l2); 23 | expect(zipped).toEqual( 24 | List([ 25 | [List([1]), List([4])], 26 | [List([2]), List([5])], 27 | [List([3]), List([6])], 28 | ]) 29 | ); 30 | expect(zipped.toJS()).toEqual([ 31 | [[1], [4]], 32 | [[2], [5]], 33 | [[3], [6]], 34 | ]); 35 | }); 36 | 37 | it('zips with infinite lists', () => { 38 | expect( 39 | Range() 40 | .zip(Seq(['A', 'B', 'C'])) 41 | .toArray() 42 | ).toEqual([ 43 | [0, 'A'], 44 | [1, 'B'], 45 | [2, 'C'], 46 | ]); 47 | }); 48 | 49 | it('has unknown size when zipped with unknown size', () => { 50 | const seq = Range(0, 10); 51 | const zipped = seq.zip(seq.filter(n => n % 2 === 0)); 52 | expect(zipped.size).toBe(undefined); 53 | expect(zipped.count()).toBe(5); 54 | }); 55 | 56 | check.it( 57 | 'is always the size of the smaller sequence', 58 | [gen.array(gen.posInt).notEmpty()], 59 | lengths => { 60 | const ranges = lengths.map(l => Range(0, l)); 61 | const first = ranges.shift(); 62 | const zipped = first.zip.apply(first, ranges); 63 | const shortestLength = Math.min.apply(Math, lengths); 64 | expect(zipped.size).toBe(shortestLength); 65 | } 66 | ); 67 | 68 | describe('zipWith', () => { 69 | it('zips with a custom function', () => { 70 | expect( 71 | Seq([1, 2, 3]) 72 | .zipWith