Mirror: 🎩 A tiny but capable push & pull stream library for TypeScript and Flow
Add pre-commit hook for bsrefmt. Run refmt over codebase. (#15)
authored by
Parker Ziegler
and committed by
Phil Plückthun
21e02f2f
6be9f26a
+2673
-1867
+930
-794
__tests__/wonka_test.re
+930
-794
__tests__/wonka_test.re
···
10
10
11
11
it("sends list items to a puller sink", () => {
12
12
let source = Wonka.fromList([10, 20, 30]);
13
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
13
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
14
14
let signals = [||];
15
15
16
-
source((.signal) => {
16
+
source((. signal) =>
17
17
switch (signal) {
18
-
| Start(x) => talkback := x;
19
-
| Push(_) => ignore(Js.Array.push(signal, signals));
18
+
| Start(x) => talkback := x
19
+
| Push(_) => ignore(Js.Array.push(signal, signals))
20
20
| End => ignore(Js.Array.push(signal, signals))
21
-
};
22
-
});
21
+
}
22
+
);
23
23
24
-
talkback^(.Pull);
25
-
talkback^(.Pull);
26
-
talkback^(.Pull);
27
-
talkback^(.Pull);
24
+
talkback^(. Pull);
25
+
talkback^(. Pull);
26
+
talkback^(. Pull);
27
+
talkback^(. Pull);
28
28
29
-
expect(signals) == [| Push(10), Push(20), Push(30), End |];
29
+
expect(signals) == [|Push(10), Push(20), Push(30), End|];
30
30
});
31
31
});
32
32
···
35
35
open! Expect.Operators;
36
36
37
37
it("sends array items to a puller sink", () => {
38
-
let source = Wonka.fromArray([| 10, 20, 30 |]);
39
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
38
+
let source = Wonka.fromArray([|10, 20, 30|]);
39
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
40
40
let signals = ref([||]);
41
41
42
-
source((.signal) => {
42
+
source((. signal) =>
43
43
switch (signal) {
44
-
| Start(x) => {
44
+
| Start(x) =>
45
45
talkback := x;
46
-
x(.Pull);
47
-
}
48
-
| Push(_) => {
46
+
x(. Pull);
47
+
| Push(_) =>
49
48
signals := Array.append(signals^, [|signal|]);
50
-
talkback^(.Pull);
49
+
talkback^(. Pull);
50
+
| End => signals := Array.append(signals^, [|signal|])
51
51
}
52
-
| End => signals := Array.append(signals^, [|signal|]);
53
-
};
54
-
});
52
+
);
55
53
56
-
expect(signals^) == [| Push(10), Push(20), Push(30), End |];
54
+
expect(signals^) == [|Push(10), Push(20), Push(30), End|];
57
55
});
58
56
59
57
it("does not blow up the stack when iterating something huge", () => {
60
58
let arr = Array.make(100000, 123);
61
59
let source = Wonka.fromArray(arr);
62
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
60
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
63
61
let values = [||];
64
62
65
-
source((.signal) => {
63
+
source((. signal) =>
66
64
switch (signal) {
67
-
| Start(x) => {
65
+
| Start(x) =>
68
66
talkback := x;
69
-
x(.Pull);
70
-
}
71
-
| Push(x) => {
67
+
x(. Pull);
68
+
| Push(x) =>
72
69
ignore(Js.Array.push(x, values));
73
-
talkback^(.Pull);
70
+
talkback^(. Pull);
71
+
| End => ()
74
72
}
75
-
| End => ()
76
-
};
77
-
});
73
+
);
78
74
79
75
expect(Array.length(values)) == Array.length(arr);
80
76
});
···
86
82
87
83
it("sends a single item to a puller sink", () => {
88
84
let source = Wonka.fromValue(123);
89
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
85
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
90
86
let signals = [||];
91
87
92
-
source((.signal) => {
88
+
source((. signal) =>
93
89
switch (signal) {
94
-
| Start(x) => talkback := x;
95
-
| Push(_) => ignore(Js.Array.push(signal, signals));
90
+
| Start(x) => talkback := x
91
+
| Push(_) => ignore(Js.Array.push(signal, signals))
96
92
| End => ignore(Js.Array.push(signal, signals))
97
-
};
98
-
});
93
+
}
94
+
);
99
95
100
-
talkback^(.Pull);
101
-
talkback^(.Pull);
102
-
talkback^(.Pull); /* one extra to check whether no signal comes back after it has ended */
96
+
talkback^(. Pull);
97
+
talkback^(. Pull);
98
+
talkback^(. Pull); /* one extra to check whether no signal comes back after it has ended */
103
99
104
-
expect(signals) == [| Push(123), End |];
100
+
expect(signals) == [|Push(123), End|];
105
101
});
106
102
});
107
103
···
110
106
open! Expect.Operators;
111
107
112
108
it("ends immediately", () => {
113
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
109
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
114
110
let signals = [||];
115
111
116
-
Wonka.empty((.signal) => {
112
+
Wonka.empty((. signal) =>
117
113
switch (signal) {
118
-
| Start(x) => talkback := x;
114
+
| Start(x) => talkback := x
119
115
| _ => ignore(Js.Array.push(signal, signals))
120
-
};
121
-
});
116
+
}
117
+
);
122
118
123
119
let _signals = Array.copy(signals);
124
120
125
-
talkback^(.Pull);
126
-
talkback^(.Pull);
121
+
talkback^(. Pull);
122
+
talkback^(. Pull);
127
123
128
-
expect((_signals, signals)) == ([| End |], [| End |]);
124
+
expect((_signals, signals)) == ([|End|], [|End|]);
129
125
});
130
126
});
131
127
···
134
130
open! Expect.Operators;
135
131
136
132
it("does not end", () => {
137
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
133
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
138
134
let ended = ref(false);
139
135
140
-
Wonka.never((.signal) => {
136
+
Wonka.never((. signal) =>
141
137
switch (signal) {
142
-
| Start(x) => talkback := x;
138
+
| Start(x) => talkback := x
143
139
| End => ended := true
144
140
| _ => ()
145
-
};
146
-
});
141
+
}
142
+
);
147
143
148
-
talkback^(.Pull);
149
-
talkback^(.Pull);
144
+
talkback^(. Pull);
145
+
talkback^(. Pull);
150
146
151
147
expect(ended^) === false;
152
148
});
···
160
156
it("maps all emissions of a source", () => {
161
157
let num = ref(1);
162
158
let nums = [||];
163
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
159
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
164
160
165
-
Wonka.map((._) => {
166
-
let res = num^;
167
-
num := num^ + 1;
168
-
res
169
-
}, sink => {
170
-
sink(.Start((.signal) => {
161
+
Wonka.map(
162
+
(. _) => {
163
+
let res = num^;
164
+
num := num^ + 1;
165
+
res;
166
+
},
167
+
sink =>
168
+
sink(.
169
+
Start(
170
+
(. signal) =>
171
+
switch (signal) {
172
+
| Pull => sink(. Push(1))
173
+
| _ => ()
174
+
},
175
+
),
176
+
),
177
+
(. signal) =>
171
178
switch (signal) {
172
-
| Pull => sink(.Push(1));
179
+
| Start(x) =>
180
+
talkback := x;
181
+
x(. Pull);
182
+
| Push(x) when num^ < 6 =>
183
+
ignore(Js.Array.push(x, nums));
184
+
talkback^(. Pull);
173
185
| _ => ()
174
-
}
175
-
}));
176
-
}, (.signal) => {
177
-
switch (signal) {
178
-
| Start(x) => {
179
-
talkback := x;
180
-
x(.Pull);
181
-
}
182
-
| Push(x) when num^ < 6 => {
183
-
ignore(Js.Array.push(x, nums));
184
-
talkback^(.Pull);
185
-
}
186
-
| _ => ()
187
-
}
188
-
});
186
+
},
187
+
);
189
188
190
-
expect(nums) |> toEqual([|1, 2, 3, 4|])
189
+
expect(nums) |> toEqual([|1, 2, 3, 4|]);
191
190
});
192
191
193
-
testPromise("follows the spec for listenables", () => {
194
-
Wonka_thelpers.testWithListenable(Wonka.map((.x) => x))
195
-
|> Js.Promise.then_(x => {
196
-
expect(x)
197
-
|> toEqual(([||], [| Push(1), Push(2), End |]))
198
-
|> Js.Promise.resolve
199
-
})
200
-
});
192
+
testPromise("follows the spec for listenables", () =>
193
+
Wonka_thelpers.testWithListenable(Wonka.map((. x) => x))
194
+
|> Js.Promise.then_(x =>
195
+
expect(x)
196
+
|> toEqual(([||], [|Push(1), Push(2), End|]))
197
+
|> Js.Promise.resolve
198
+
)
199
+
);
201
200
202
-
testPromise("ends itself and source when its talkback receives the End signal", () => {
201
+
testPromise(
202
+
"ends itself and source when its talkback receives the End signal", () => {
203
203
let end_: talkbackT = Close;
204
204
205
-
Wonka_thelpers.testTalkbackEnd(Wonka.map((.x) => x))
206
-
|> Js.Promise.then_(x => {
207
-
expect(x)
208
-
|> toEqual(([| end_ |], [| Push(1) |]))
209
-
|> Js.Promise.resolve
210
-
})
205
+
Wonka_thelpers.testTalkbackEnd(Wonka.map((. x) => x))
206
+
|> Js.Promise.then_(x =>
207
+
expect(x)
208
+
|> toEqual(([|end_|], [|Push(1)|]))
209
+
|> Js.Promise.resolve
210
+
);
211
211
});
212
212
});
213
213
···
217
217
it("filters emissions according to a predicate", () => {
218
218
let i = ref(1);
219
219
let nums = [||];
220
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
220
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
221
221
222
-
Wonka.filter((.x) => x mod 2 === 0, sink => {
223
-
sink(.Start((.signal) => {
222
+
Wonka.filter(
223
+
(. x) => x mod 2 === 0,
224
+
sink =>
225
+
sink(.
226
+
Start(
227
+
(. signal) =>
228
+
switch (signal) {
229
+
| Pull =>
230
+
let num = i^;
231
+
i := i^ + 1;
232
+
sink(. Push(num));
233
+
| _ => ()
234
+
},
235
+
),
236
+
),
237
+
(. signal) =>
224
238
switch (signal) {
225
-
| Pull => {
226
-
let num = i^;
227
-
i := i^ + 1;
228
-
sink(.Push(num));
229
-
}
239
+
| Start(x) =>
240
+
talkback := x;
241
+
x(. Pull);
242
+
| Push(x) when x < 6 =>
243
+
ignore(Js.Array.push(x, nums));
244
+
talkback^(. Pull);
230
245
| _ => ()
231
-
}
232
-
}));
233
-
}, (.signal) => {
234
-
switch (signal) {
235
-
| Start(x) => {
236
-
talkback := x;
237
-
x(.Pull);
238
-
}
239
-
| Push(x) when x < 6 => {
240
-
ignore(Js.Array.push(x, nums));
241
-
talkback^(.Pull);
242
-
}
243
-
| _ => ()
244
-
}
245
-
});
246
+
},
247
+
);
246
248
247
-
expect(nums) |> toEqual([|2, 4|])
249
+
expect(nums) |> toEqual([|2, 4|]);
248
250
});
249
251
250
-
testPromise("follows the spec for listenables", () => {
251
-
Wonka_thelpers.testWithListenable(Wonka.filter((._) => true))
252
-
|> Js.Promise.then_(x => {
253
-
expect(x)
254
-
|> toEqual(([||], [| Push(1), Push(2), End |]))
255
-
|> Js.Promise.resolve
256
-
})
257
-
});
252
+
testPromise("follows the spec for listenables", () =>
253
+
Wonka_thelpers.testWithListenable(Wonka.filter((. _) => true))
254
+
|> Js.Promise.then_(x =>
255
+
expect(x)
256
+
|> toEqual(([||], [|Push(1), Push(2), End|]))
257
+
|> Js.Promise.resolve
258
+
)
259
+
);
258
260
259
-
testPromise("follows the spec for listenables when filtering", () => {
260
-
Wonka_thelpers.testWithListenable(Wonka.filter((._) => false))
261
-
|> Js.Promise.then_(x => {
262
-
expect(x)
263
-
|> toEqual(([| Pull, Pull |], [| End |]))
264
-
|> Js.Promise.resolve
265
-
})
266
-
});
261
+
testPromise("follows the spec for listenables when filtering", () =>
262
+
Wonka_thelpers.testWithListenable(Wonka.filter((. _) => false))
263
+
|> Js.Promise.then_(x =>
264
+
expect(x)
265
+
|> toEqual(([|Pull, Pull|], [|End|]))
266
+
|> Js.Promise.resolve
267
+
)
268
+
);
267
269
268
-
testPromise("ends itself and source when its talkback receives the End signal", () => {
270
+
testPromise(
271
+
"ends itself and source when its talkback receives the End signal", () => {
269
272
let end_: talkbackT = Close;
270
273
271
-
Wonka_thelpers.testTalkbackEnd(Wonka.filter((._) => true))
272
-
|> Js.Promise.then_(x => {
273
-
expect(x)
274
-
|> toEqual(([| end_ |], [| Push(1) |]))
275
-
|> Js.Promise.resolve
276
-
})
274
+
Wonka_thelpers.testTalkbackEnd(Wonka.filter((. _) => true))
275
+
|> Js.Promise.then_(x =>
276
+
expect(x)
277
+
|> toEqual(([|end_|], [|Push(1)|]))
278
+
|> Js.Promise.resolve
279
+
);
277
280
});
278
281
});
279
282
···
281
284
open Expect;
282
285
283
286
it("folds emissions using an initial seed value", () => {
284
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
287
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
285
288
let num = ref(1);
286
289
287
-
let source = Wonka.scan((.acc, x) => acc + x, 0, sink => sink(.Start((.signal) => {
288
-
switch (signal) {
289
-
| Pull => {
290
-
let i = num^;
291
-
if (i <= 3) {
292
-
num := num^ + 1;
293
-
sink(.Push(i));
294
-
} else {
295
-
sink(.End);
296
-
}
297
-
}
298
-
| _ => ()
299
-
}
300
-
})));
290
+
let source =
291
+
Wonka.scan(
292
+
(. acc, x) => acc + x,
293
+
0,
294
+
sink =>
295
+
sink(.
296
+
Start(
297
+
(. signal) =>
298
+
switch (signal) {
299
+
| Pull =>
300
+
let i = num^;
301
+
if (i <= 3) {
302
+
num := num^ + 1;
303
+
sink(. Push(i));
304
+
} else {
305
+
sink(. End);
306
+
};
307
+
| _ => ()
308
+
},
309
+
),
310
+
),
311
+
);
301
312
302
313
let res = [||];
303
314
304
-
source((.signal) => {
315
+
source((. signal) =>
305
316
switch (signal) {
306
317
| Start(x) => talkback := x
307
318
| _ => ignore(Js.Array.push(signal, res))
308
319
}
309
-
});
320
+
);
310
321
311
-
talkback^(.Pull);
312
-
talkback^(.Pull);
313
-
talkback^(.Pull);
314
-
talkback^(.Pull);
315
-
expect(res) |> toEqual([| Push(1), Push(3), Push(6), End |]);
322
+
talkback^(. Pull);
323
+
talkback^(. Pull);
324
+
talkback^(. Pull);
325
+
talkback^(. Pull);
326
+
expect(res) |> toEqual([|Push(1), Push(3), Push(6), End|]);
316
327
});
317
328
318
-
testPromise("follows the spec for listenables", () => {
319
-
Wonka_thelpers.testWithListenable(Wonka.scan((._, x) => x, 0))
320
-
|> Js.Promise.then_(x => {
321
-
expect(x)
322
-
|> toEqual(([||], [| Push(1), Push(2), End |]))
323
-
|> Js.Promise.resolve
324
-
})
325
-
});
329
+
testPromise("follows the spec for listenables", () =>
330
+
Wonka_thelpers.testWithListenable(Wonka.scan((. _, x) => x, 0))
331
+
|> Js.Promise.then_(x =>
332
+
expect(x)
333
+
|> toEqual(([||], [|Push(1), Push(2), End|]))
334
+
|> Js.Promise.resolve
335
+
)
336
+
);
326
337
327
-
testPromise("ends itself and source when its talkback receives the End signal", () => {
338
+
testPromise(
339
+
"ends itself and source when its talkback receives the End signal", () => {
328
340
let end_: talkbackT = Close;
329
341
330
-
Wonka_thelpers.testTalkbackEnd(Wonka.scan((._, x) => x, 0))
331
-
|> Js.Promise.then_(x => {
332
-
expect(x)
333
-
|> toEqual(([| end_ |], [| Push(1) |]))
334
-
|> Js.Promise.resolve
335
-
})
342
+
Wonka_thelpers.testTalkbackEnd(Wonka.scan((. _, x) => x, 0))
343
+
|> Js.Promise.then_(x =>
344
+
expect(x)
345
+
|> toEqual(([|end_|], [|Push(1)|]))
346
+
|> Js.Promise.resolve
347
+
);
336
348
});
337
349
});
338
350
···
343
355
it("merges different sources into a single one", () => {
344
356
let a = Wonka.fromList([1, 2, 3]);
345
357
let b = Wonka.fromList([4, 5, 6]);
346
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
358
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
347
359
let signals = [||];
348
-
let source = Wonka.merge([| a, b |]);
360
+
let source = Wonka.merge([|a, b|]);
349
361
350
-
source((.signal) => {
362
+
source((. signal) =>
351
363
switch (signal) {
352
-
| Start(x) => {
364
+
| Start(x) =>
353
365
talkback := x;
354
-
x(.Pull);
355
-
}
356
-
| Push(_) => {
366
+
x(. Pull);
367
+
| Push(_) =>
357
368
ignore(Js.Array.push(signal, signals));
358
-
talkback^(.Pull);
369
+
talkback^(. Pull);
370
+
| End => ignore(Js.Array.push(signal, signals))
359
371
}
360
-
| End => ignore(Js.Array.push(signal, signals))
361
-
};
362
-
});
372
+
);
363
373
364
-
expect(signals) == [| Push(1), Push(2), Push(3), Push(4), Push(5), Push(6), End |];
374
+
expect(signals)
375
+
== [|Push(1), Push(2), Push(3), Push(4), Push(5), Push(6), End|];
365
376
});
366
377
367
-
testPromise("follows the spec for listenables", () => {
378
+
testPromise("follows the spec for listenables", () =>
368
379
Wonka_thelpers.testWithListenable(source => Wonka.merge([|source|]))
369
-
|> Js.Promise.then_(x => {
370
-
expect(x)
371
-
|> toEqual(([| Pull, Pull, Pull |], [| Push(1), Push(2), End |]))
372
-
|> Js.Promise.resolve
373
-
})
374
-
});
380
+
|> Js.Promise.then_(x =>
381
+
expect(x)
382
+
|> toEqual(([|Pull, Pull, Pull|], [|Push(1), Push(2), End|]))
383
+
|> Js.Promise.resolve
384
+
)
385
+
);
375
386
376
-
testPromise("ends itself and source when its talkback receives the End signal", () => {
387
+
testPromise(
388
+
"ends itself and source when its talkback receives the End signal", () =>
377
389
Wonka_thelpers.testTalkbackEnd(source => Wonka.merge([|source|]))
378
-
|> Js.Promise.then_(x => {
379
-
expect(x)
380
-
|> toEqual(([| Pull, Pull, Close |], [| Push(1) |]))
381
-
|> Js.Promise.resolve
382
-
})
383
-
});
390
+
|> Js.Promise.then_(x =>
391
+
expect(x)
392
+
|> toEqual(([|Pull, Pull, Close|], [|Push(1)|]))
393
+
|> Js.Promise.resolve
394
+
)
395
+
);
384
396
});
385
397
386
398
describe("concat", () => {
···
390
402
it("concatenates different sources into a single one", () => {
391
403
let a = Wonka.fromList([1, 2, 3]);
392
404
let b = Wonka.fromList([4, 5, 6]);
393
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
405
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
394
406
let signals = [||];
395
-
let source = Wonka.concat([| a, b |]);
407
+
let source = Wonka.concat([|a, b|]);
396
408
397
-
source((.signal) => {
409
+
source((. signal) =>
398
410
switch (signal) {
399
-
| Start(x) => {
411
+
| Start(x) =>
400
412
talkback := x;
401
-
x(.Pull);
402
-
}
403
-
| Push(_) => {
413
+
x(. Pull);
414
+
| Push(_) =>
404
415
ignore(Js.Array.push(signal, signals));
405
-
talkback^(.Pull);
416
+
talkback^(. Pull);
417
+
| End => ignore(Js.Array.push(signal, signals))
406
418
}
407
-
| End => ignore(Js.Array.push(signal, signals))
408
-
};
409
-
});
419
+
);
410
420
411
-
expect(signals) == [| Push(1), Push(2), Push(3), Push(4), Push(5), Push(6), End |];
421
+
expect(signals)
422
+
== [|Push(1), Push(2), Push(3), Push(4), Push(5), Push(6), End|];
412
423
});
413
424
414
-
testPromise("follows the spec for listenables", () => {
425
+
testPromise("follows the spec for listenables", () =>
415
426
Wonka_thelpers.testWithListenable(source => Wonka.concat([|source|]))
416
-
|> Js.Promise.then_(x => {
417
-
expect(x)
418
-
|> toEqual(([| Pull, Pull, Pull |], [| Push(1), Push(2), End |]))
419
-
|> Js.Promise.resolve
420
-
})
421
-
});
427
+
|> Js.Promise.then_(x =>
428
+
expect(x)
429
+
|> toEqual(([|Pull, Pull, Pull|], [|Push(1), Push(2), End|]))
430
+
|> Js.Promise.resolve
431
+
)
432
+
);
422
433
423
-
testPromise("ends itself and source when its talkback receives the End signal", () => {
434
+
testPromise(
435
+
"ends itself and source when its talkback receives the End signal", () =>
424
436
Wonka_thelpers.testTalkbackEnd(source => Wonka.concat([|source|]))
425
-
|> Js.Promise.then_(x => {
426
-
expect(x)
427
-
|> toEqual(([| Pull, Pull, Close |], [| Push(1) |]))
428
-
|> Js.Promise.resolve
429
-
})
430
-
});
437
+
|> Js.Promise.then_(x =>
438
+
expect(x)
439
+
|> toEqual(([|Pull, Pull, Close|], [|Push(1)|]))
440
+
|> Js.Promise.resolve
441
+
)
442
+
);
431
443
});
432
444
433
445
describe("share", () => {
434
446
open Expect;
435
447
436
448
it("shares an underlying source with all sinks", () => {
437
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
438
-
let aborterTb = ref((._: Wonka_types.talkbackT) => ());
449
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
450
+
let aborterTb = ref((. _: Wonka_types.talkbackT) => ());
439
451
let num = ref(1);
440
452
let nums = [||];
441
453
442
-
let source = Wonka.share(sink => {
443
-
sink(.Start((.signal) => {
444
-
switch (signal) {
445
-
| Pull => {
446
-
let i = num^;
447
-
if (i <= 2) {
448
-
num := num^ + 1;
449
-
sink(.Push(i));
450
-
} else {
451
-
sink(.End);
452
-
}
453
-
}
454
-
| _ => ()
455
-
}
456
-
}));
457
-
});
454
+
let source =
455
+
Wonka.share(sink =>
456
+
sink(.
457
+
Start(
458
+
(. signal) =>
459
+
switch (signal) {
460
+
| Pull =>
461
+
let i = num^;
462
+
if (i <= 2) {
463
+
num := num^ + 1;
464
+
sink(. Push(i));
465
+
} else {
466
+
sink(. End);
467
+
};
468
+
| _ => ()
469
+
},
470
+
),
471
+
)
472
+
);
458
473
459
-
source((.signal) => {
474
+
source((. signal) =>
460
475
switch (signal) {
461
476
| Start(x) => talkback := x
462
477
| _ => ignore(Js.Array.push(signal, nums))
463
478
}
464
-
});
479
+
);
465
480
466
-
source((.signal) => {
481
+
source((. signal) =>
467
482
switch (signal) {
468
483
| Start(_) => ()
469
484
| _ => ignore(Js.Array.push(signal, nums))
470
485
}
471
-
});
486
+
);
472
487
473
-
source((.signal) => {
488
+
source((. signal) =>
474
489
switch (signal) {
475
490
| Start(tb) => aborterTb := tb
476
-
| _ => {
491
+
| _ =>
477
492
ignore(Js.Array.push(signal, nums));
478
-
aborterTb^(.Close);
493
+
aborterTb^(. Close);
479
494
}
480
-
}
481
-
});
495
+
);
482
496
483
-
talkback^(.Pull);
497
+
talkback^(. Pull);
484
498
let numsA = Array.copy(nums);
485
-
talkback^(.Pull);
486
-
talkback^(.Pull);
487
-
talkback^(.Pull);
488
-
expect((numsA, nums)) |> toEqual(([| Push(1), Push(1), Push(1) |], [| Push(1), Push(1), Push(1), Push(2), Push(2), End, End |]));
499
+
talkback^(. Pull);
500
+
talkback^(. Pull);
501
+
talkback^(. Pull);
502
+
expect((numsA, nums))
503
+
|> toEqual((
504
+
[|Push(1), Push(1), Push(1)|],
505
+
[|Push(1), Push(1), Push(1), Push(2), Push(2), End, End|],
506
+
));
489
507
});
490
508
491
-
testPromise("follows the spec for listenables", () => {
509
+
testPromise("follows the spec for listenables", () =>
492
510
Wonka_thelpers.testWithListenable(Wonka.share)
493
-
|> Js.Promise.then_(x => {
494
-
expect(x)
495
-
|> toEqual(([||], [| Push(1), Push(2), End |]))
496
-
|> Js.Promise.resolve
497
-
})
498
-
});
511
+
|> Js.Promise.then_(x =>
512
+
expect(x)
513
+
|> toEqual(([||], [|Push(1), Push(2), End|]))
514
+
|> Js.Promise.resolve
515
+
)
516
+
);
499
517
500
-
testPromise("ends itself and source when its talkback receives the End signal", () => {
518
+
testPromise(
519
+
"ends itself and source when its talkback receives the End signal", () => {
501
520
let end_: talkbackT = Close;
502
521
503
522
Wonka_thelpers.testTalkbackEnd(Wonka.share)
504
-
|> Js.Promise.then_(x => {
505
-
expect(x)
506
-
|> toEqual(([| end_ |], [| Push(1) |]))
507
-
|> Js.Promise.resolve
508
-
})
523
+
|> Js.Promise.then_(x =>
524
+
expect(x)
525
+
|> toEqual(([|end_|], [|Push(1)|]))
526
+
|> Js.Promise.resolve
527
+
);
509
528
});
510
529
});
511
530
···
513
532
open Expect;
514
533
515
534
it("combines the latest values of two sources", () => {
516
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
535
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
517
536
518
537
let makeSource = (factor: int) => {
519
538
let num = ref(1);
520
539
521
540
sink => {
522
-
sink(.Start((.signal) => {
523
-
switch (signal) {
524
-
| Pull => {
525
-
if (num^ <= 2) {
526
-
let i = num^ * factor;
527
-
num := num^ + 1;
528
-
sink(.Push(i));
529
-
} else {
530
-
sink(.End);
531
-
}
532
-
}
533
-
| _ => ()
534
-
}
535
-
}));
536
-
}
541
+
sink(.
542
+
Start(
543
+
(. signal) =>
544
+
switch (signal) {
545
+
| Pull =>
546
+
if (num^ <= 2) {
547
+
let i = num^ * factor;
548
+
num := num^ + 1;
549
+
sink(. Push(i));
550
+
} else {
551
+
sink(. End);
552
+
}
553
+
| _ => ()
554
+
},
555
+
),
556
+
);
557
+
};
537
558
};
538
559
539
560
let sourceA = makeSource(1);
···
541
562
let source = Wonka.combine(sourceA, sourceB);
542
563
let res = [||];
543
564
544
-
source((.signal) => {
565
+
source((. signal) =>
545
566
switch (signal) {
546
567
| Start(x) => talkback := x
547
568
| _ => ignore(Js.Array.push(signal, res))
548
569
}
549
-
});
570
+
);
550
571
551
-
talkback^(.Pull);
552
-
talkback^(.Pull);
553
-
talkback^(.Pull);
554
-
talkback^(.Pull);
555
-
expect(res) |> toEqual([| Push((1, 2)), Push((2, 2)), Push((2, 4)), End |]);
572
+
talkback^(. Pull);
573
+
talkback^(. Pull);
574
+
talkback^(. Pull);
575
+
talkback^(. Pull);
576
+
expect(res)
577
+
|> toEqual([|Push((1, 2)), Push((2, 2)), Push((2, 4)), End|]);
556
578
});
557
579
558
-
testPromise("follows the spec for listenables", () => {
580
+
testPromise("follows the spec for listenables", () =>
559
581
Wonka_thelpers.testWithListenable(source => {
560
582
let shared = Wonka.share(source);
561
-
Wonka.combine(shared, shared)
583
+
Wonka.combine(shared, shared);
562
584
})
563
-
|> Js.Promise.then_(x => {
564
-
expect(x)
565
-
|> toEqual(([||], [| Push((1, 1)), Push((2, 1)), Push((2, 2)), End |]))
566
-
|> Js.Promise.resolve
567
-
})
568
-
});
585
+
|> Js.Promise.then_(x =>
586
+
expect(x)
587
+
|> toEqual((
588
+
[||],
589
+
[|Push((1, 1)), Push((2, 1)), Push((2, 2)), End|],
590
+
))
591
+
|> Js.Promise.resolve
592
+
)
593
+
);
569
594
570
-
testPromise("ends itself and source when its talkback receives the End signal", () => {
595
+
testPromise(
596
+
"ends itself and source when its talkback receives the End signal", () => {
571
597
let end_: talkbackT = Close;
572
598
573
599
Wonka_thelpers.testTalkbackEnd(source => {
574
600
let shared = Wonka.share(source);
575
-
Wonka.combine(shared, shared)
601
+
Wonka.combine(shared, shared);
576
602
})
577
-
|> Js.Promise.then_(x => {
578
-
expect(x)
579
-
|> toEqual(([| end_ |], [| Push((1, 1)) |]))
580
-
|> Js.Promise.resolve
581
-
})
603
+
|> Js.Promise.then_(x =>
604
+
expect(x)
605
+
|> toEqual(([|end_|], [|Push((1, 1))|]))
606
+
|> Js.Promise.resolve
607
+
);
582
608
});
583
609
});
584
610
···
586
612
open Expect;
587
613
588
614
it("only lets a maximum number of values through", () => {
589
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
615
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
590
616
let num = ref(1);
591
617
592
-
let source = Wonka.take(2, sink => sink(.Start((.signal) => {
593
-
switch (signal) {
594
-
| Pull => {
595
-
let i = num^;
596
-
num := num^ + 1;
597
-
sink(.Push(i));
598
-
}
599
-
| _ => ()
600
-
}
601
-
})));
618
+
let source =
619
+
Wonka.take(2, sink =>
620
+
sink(.
621
+
Start(
622
+
(. signal) =>
623
+
switch (signal) {
624
+
| Pull =>
625
+
let i = num^;
626
+
num := num^ + 1;
627
+
sink(. Push(i));
628
+
| _ => ()
629
+
},
630
+
),
631
+
)
632
+
);
602
633
603
634
let res = [||];
604
635
605
-
source((.signal) => {
636
+
source((. signal) =>
606
637
switch (signal) {
607
638
| Start(x) => talkback := x
608
639
| _ => ignore(Js.Array.push(signal, res))
609
640
}
610
-
});
641
+
);
611
642
612
-
talkback^(.Pull);
613
-
talkback^(.Pull);
614
-
talkback^(.Pull);
615
-
talkback^(.Pull);
616
-
expect(res) |> toEqual([| Push(1), Push(2), End |]);
643
+
talkback^(. Pull);
644
+
talkback^(. Pull);
645
+
talkback^(. Pull);
646
+
talkback^(. Pull);
647
+
expect(res) |> toEqual([|Push(1), Push(2), End|]);
617
648
});
618
649
619
-
it("accepts the end of the source when max number of emissions is not reached", () => {
620
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
650
+
it(
651
+
"accepts the end of the source when max number of emissions is not reached",
652
+
() => {
653
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
621
654
let num = ref(1);
622
655
623
-
let source = Wonka.take(2, sink => sink(.Start((.signal) => {
624
-
switch (signal) {
625
-
| Pull => {
626
-
let i = num^;
627
-
if (i < 2) {
628
-
num := num^ + 1;
629
-
sink(.Push(i));
630
-
} else {
631
-
sink(.End);
632
-
}
633
-
}
634
-
| _ => ()
635
-
}
636
-
})));
656
+
let source =
657
+
Wonka.take(2, sink =>
658
+
sink(.
659
+
Start(
660
+
(. signal) =>
661
+
switch (signal) {
662
+
| Pull =>
663
+
let i = num^;
664
+
if (i < 2) {
665
+
num := num^ + 1;
666
+
sink(. Push(i));
667
+
} else {
668
+
sink(. End);
669
+
};
670
+
| _ => ()
671
+
},
672
+
),
673
+
)
674
+
);
637
675
638
676
let res = [||];
639
677
640
-
source((.signal) => {
678
+
source((. signal) =>
641
679
switch (signal) {
642
680
| Start(x) => talkback := x
643
681
| _ => ignore(Js.Array.push(signal, res))
644
682
}
645
-
});
683
+
);
646
684
647
-
talkback^(.Pull);
648
-
talkback^(.Pull);
649
-
talkback^(.Pull);
650
-
expect(res) |> toEqual([| Push(1), End |]);
685
+
talkback^(. Pull);
686
+
talkback^(. Pull);
687
+
talkback^(. Pull);
688
+
expect(res) |> toEqual([|Push(1), End|]);
651
689
});
652
690
653
-
testPromise("follows the spec for listenables", () => {
691
+
testPromise("follows the spec for listenables", () =>
654
692
Wonka_thelpers.testWithListenable(Wonka.take(10))
655
-
|> Js.Promise.then_(x => {
656
-
expect(x)
657
-
|> toEqual(([||], [| Push(1), Push(2), End |]))
658
-
|> Js.Promise.resolve
659
-
})
660
-
});
693
+
|> Js.Promise.then_(x =>
694
+
expect(x)
695
+
|> toEqual(([||], [|Push(1), Push(2), End|]))
696
+
|> Js.Promise.resolve
697
+
)
698
+
);
661
699
662
700
testPromise("follows the spec for listenables when ending the source", () => {
663
701
let end_: talkbackT = Close;
664
702
665
703
Wonka_thelpers.testWithListenable(Wonka.take(1))
666
-
|> Js.Promise.then_(x => {
667
-
expect(x)
668
-
|> toEqual(([| end_ |], [| Push(1), End |]))
669
-
|> Js.Promise.resolve
670
-
})
704
+
|> Js.Promise.then_(x =>
705
+
expect(x)
706
+
|> toEqual(([|end_|], [|Push(1), End|]))
707
+
|> Js.Promise.resolve
708
+
);
671
709
});
672
710
673
-
testPromise("ends itself and source when its talkback receives the End signal", () => {
711
+
testPromise(
712
+
"ends itself and source when its talkback receives the End signal", () => {
674
713
let end_: talkbackT = Close;
675
714
676
715
Wonka_thelpers.testTalkbackEnd(Wonka.take(10))
677
-
|> Js.Promise.then_(x => {
678
-
expect(x)
679
-
|> toEqual(([| end_ |], [| Push(1) |]))
680
-
|> Js.Promise.resolve
681
-
})
716
+
|> Js.Promise.then_(x =>
717
+
expect(x)
718
+
|> toEqual(([|end_|], [|Push(1)|]))
719
+
|> Js.Promise.resolve
720
+
);
682
721
});
683
722
});
684
723
···
686
725
open Expect;
687
726
688
727
it("only lets the last n values through on an entirely new source", () => {
689
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
728
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
690
729
let num = ref(1);
691
730
692
-
let source = Wonka.takeLast(2, sink => sink(.Start((.signal) => {
693
-
switch (signal) {
694
-
| Pull when num^ <= 4 => {
695
-
let i = num^;
696
-
num := num^ + 1;
697
-
sink(.Push(i));
698
-
}
699
-
| Pull => sink(.End)
700
-
| _ => ()
701
-
}
702
-
})));
731
+
let source =
732
+
Wonka.takeLast(2, sink =>
733
+
sink(.
734
+
Start(
735
+
(. signal) =>
736
+
switch (signal) {
737
+
| Pull when num^ <= 4 =>
738
+
let i = num^;
739
+
num := num^ + 1;
740
+
sink(. Push(i));
741
+
| Pull => sink(. End)
742
+
| _ => ()
743
+
},
744
+
),
745
+
)
746
+
);
703
747
704
748
let res = [||];
705
749
706
-
source((.signal) => {
750
+
source((. signal) =>
707
751
switch (signal) {
708
752
| Start(x) => talkback := x
709
753
| _ => ignore(Js.Array.push(signal, res))
710
754
}
711
-
});
755
+
);
712
756
713
-
talkback^(.Pull);
714
-
talkback^(.Pull);
715
-
talkback^(.Pull);
716
-
expect(res) |> toEqual([| Push(3), Push(4), End |]);
757
+
talkback^(. Pull);
758
+
talkback^(. Pull);
759
+
talkback^(. Pull);
760
+
expect(res) |> toEqual([|Push(3), Push(4), End|]);
717
761
});
718
762
719
-
testPromise("follows the spec for listenables", () => {
763
+
testPromise("follows the spec for listenables", () =>
720
764
Wonka_thelpers.testWithListenable(Wonka.takeLast(10))
721
-
|> Js.Promise.then_(x => {
722
-
expect(x)
723
-
|> toEqual(([| Pull, Pull, Pull |], [| /* empty since the source is a pullable */ |]))
724
-
|> Js.Promise.resolve
725
-
})
726
-
});
765
+
|> Js.Promise.then_(x =>
766
+
expect(x)
767
+
|> toEqual((
768
+
[|Pull, Pull, Pull|],
769
+
[|/* empty since the source is a pullable */|],
770
+
))
771
+
|> Js.Promise.resolve
772
+
)
773
+
);
727
774
728
-
testPromise("ends itself and source when its talkback receives the End signal", () => {
775
+
testPromise(
776
+
"ends itself and source when its talkback receives the End signal", () =>
729
777
Wonka_thelpers.testTalkbackEnd(Wonka.takeLast(10))
730
-
|> Js.Promise.then_(x => {
731
-
expect(x)
732
-
|> toEqual(([| Pull, Pull |], [| |]))
733
-
|> Js.Promise.resolve
734
-
})
735
-
});
778
+
|> Js.Promise.then_(x =>
779
+
expect(x)
780
+
|> toEqual(([|Pull, Pull|], [||]))
781
+
|> Js.Promise.resolve
782
+
)
783
+
);
736
784
});
737
785
738
786
describe("takeWhile", () => {
739
787
open Expect;
740
788
741
789
it("only lets the last n values through on an entirely new source", () => {
742
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
790
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
743
791
let num = ref(1);
744
792
745
-
let source = Wonka.takeWhile((.x) => x <= 2, sink => sink(.Start((.signal) => {
746
-
switch (signal) {
747
-
| Pull => {
748
-
let i = num^;
749
-
num := num^ + 1;
750
-
sink(.Push(i));
751
-
}
752
-
| _ => ()
753
-
}
754
-
})));
793
+
let source =
794
+
Wonka.takeWhile(
795
+
(. x) => x <= 2,
796
+
sink =>
797
+
sink(.
798
+
Start(
799
+
(. signal) =>
800
+
switch (signal) {
801
+
| Pull =>
802
+
let i = num^;
803
+
num := num^ + 1;
804
+
sink(. Push(i));
805
+
| _ => ()
806
+
},
807
+
),
808
+
),
809
+
);
755
810
756
811
let res = [||];
757
812
758
-
source((.signal) => {
813
+
source((. signal) =>
759
814
switch (signal) {
760
815
| Start(x) => talkback := x
761
816
| _ => ignore(Js.Array.push(signal, res))
762
817
}
763
-
});
818
+
);
764
819
765
-
talkback^(.Pull);
766
-
talkback^(.Pull);
767
-
talkback^(.Pull);
768
-
talkback^(.Pull);
820
+
talkback^(. Pull);
821
+
talkback^(. Pull);
822
+
talkback^(. Pull);
823
+
talkback^(. Pull);
769
824
770
-
expect(res) |> toEqual([| Push(1), Push(2), End |]);
825
+
expect(res) |> toEqual([|Push(1), Push(2), End|]);
771
826
});
772
827
773
-
it("accepts the end of the source when max number of emissions is not reached", () => {
774
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
828
+
it(
829
+
"accepts the end of the source when max number of emissions is not reached",
830
+
() => {
831
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
775
832
let num = ref(1);
776
833
777
-
let source = Wonka.takeWhile((.x) => x <= 5, sink => sink(.Start((.signal) => {
778
-
switch (signal) {
779
-
| Pull => {
780
-
let i = num^;
781
-
if (i < 2) {
782
-
num := num^ + 1;
783
-
sink(.Push(i));
784
-
} else {
785
-
sink(.End);
786
-
}
787
-
}
788
-
| _ => ()
789
-
}
790
-
})));
834
+
let source =
835
+
Wonka.takeWhile(
836
+
(. x) => x <= 5,
837
+
sink =>
838
+
sink(.
839
+
Start(
840
+
(. signal) =>
841
+
switch (signal) {
842
+
| Pull =>
843
+
let i = num^;
844
+
if (i < 2) {
845
+
num := num^ + 1;
846
+
sink(. Push(i));
847
+
} else {
848
+
sink(. End);
849
+
};
850
+
| _ => ()
851
+
},
852
+
),
853
+
),
854
+
);
791
855
792
856
let res = [||];
793
857
794
-
source((.signal) => {
858
+
source((. signal) =>
795
859
switch (signal) {
796
860
| Start(x) => talkback := x
797
861
| _ => ignore(Js.Array.push(signal, res))
798
862
}
799
-
});
863
+
);
800
864
801
-
talkback^(.Pull);
802
-
talkback^(.Pull);
803
-
talkback^(.Pull);
865
+
talkback^(. Pull);
866
+
talkback^(. Pull);
867
+
talkback^(. Pull);
804
868
805
-
expect(res) |> toEqual([| Push(1), End |]);
869
+
expect(res) |> toEqual([|Push(1), End|]);
806
870
});
807
871
808
-
testPromise("follows the spec for listenables", () => {
809
-
Wonka_thelpers.testWithListenable(Wonka.takeWhile((._) => true))
810
-
|> Js.Promise.then_(x => {
811
-
expect(x)
812
-
|> toEqual(([||], [| Push(1), Push(2), End |]))
813
-
|> Js.Promise.resolve
814
-
})
815
-
});
872
+
testPromise("follows the spec for listenables", () =>
873
+
Wonka_thelpers.testWithListenable(Wonka.takeWhile((. _) => true))
874
+
|> Js.Promise.then_(x =>
875
+
expect(x)
876
+
|> toEqual(([||], [|Push(1), Push(2), End|]))
877
+
|> Js.Promise.resolve
878
+
)
879
+
);
816
880
817
881
testPromise("follows the spec for listenables when ending the source", () => {
818
882
let end_: talkbackT = Close;
819
883
820
-
Wonka_thelpers.testWithListenable(Wonka.takeWhile((._) => false))
821
-
|> Js.Promise.then_(x => {
822
-
expect(x)
823
-
|> toEqual(([| end_ |], [| End |]))
824
-
|> Js.Promise.resolve
825
-
})
884
+
Wonka_thelpers.testWithListenable(Wonka.takeWhile((. _) => false))
885
+
|> Js.Promise.then_(x =>
886
+
expect(x) |> toEqual(([|end_|], [|End|])) |> Js.Promise.resolve
887
+
);
826
888
});
827
889
828
-
testPromise("ends itself and source when its talkback receives the End signal", () => {
890
+
testPromise(
891
+
"ends itself and source when its talkback receives the End signal", () => {
829
892
let end_: talkbackT = Close;
830
893
831
-
Wonka_thelpers.testTalkbackEnd(Wonka.takeWhile((._) => true))
832
-
|> Js.Promise.then_(x => {
833
-
expect(x)
834
-
|> toEqual(([| end_ |], [| Push(1) |]))
835
-
|> Js.Promise.resolve
836
-
})
894
+
Wonka_thelpers.testTalkbackEnd(Wonka.takeWhile((. _) => true))
895
+
|> Js.Promise.then_(x =>
896
+
expect(x)
897
+
|> toEqual(([|end_|], [|Push(1)|]))
898
+
|> Js.Promise.resolve
899
+
);
837
900
});
838
901
});
839
902
···
841
904
open Expect;
842
905
843
906
it("only lets the last n values through on an entirely new source", () => {
844
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
907
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
845
908
let notify = ref((_: Wonka_types.talkbackT) => ());
846
909
let num = ref(1);
847
910
848
911
let notifier = sink => {
849
-
notify := signal => switch (signal) {
850
-
| Pull => sink(.Push(0));
851
-
| _ => ()
852
-
};
912
+
notify :=
913
+
(
914
+
signal =>
915
+
switch (signal) {
916
+
| Pull => sink(. Push(0))
917
+
| _ => ()
918
+
}
919
+
);
853
920
854
-
sink(.Start(Wonka_helpers.talkbackPlaceholder));
921
+
sink(. Start(Wonka_helpers.talkbackPlaceholder));
855
922
};
856
923
857
-
let source = Wonka.takeUntil(notifier, sink => sink(.Start((.signal) => {
858
-
switch (signal) {
859
-
| Pull when num^ <= 4 => {
860
-
let i = num^;
861
-
if (i === 3) notify^(Pull);
862
-
num := num^ + 1;
863
-
sink(.Push(i));
864
-
}
865
-
| _ => ()
866
-
}
867
-
})));
924
+
let source =
925
+
Wonka.takeUntil(notifier, sink =>
926
+
sink(.
927
+
Start(
928
+
(. signal) =>
929
+
switch (signal) {
930
+
| Pull when num^ <= 4 =>
931
+
let i = num^;
932
+
if (i === 3) {
933
+
notify^(Pull);
934
+
};
935
+
num := num^ + 1;
936
+
sink(. Push(i));
937
+
| _ => ()
938
+
},
939
+
),
940
+
)
941
+
);
868
942
869
943
let res = [||];
870
944
871
-
source((.signal) => {
945
+
source((. signal) =>
872
946
switch (signal) {
873
947
| Start(x) => talkback := x
874
948
| _ => ignore(Js.Array.push(signal, res))
875
949
}
876
-
});
950
+
);
877
951
878
-
talkback^(.Pull);
879
-
talkback^(.Pull);
880
-
talkback^(.Pull);
881
-
talkback^(.Pull);
952
+
talkback^(. Pull);
953
+
talkback^(. Pull);
954
+
talkback^(. Pull);
955
+
talkback^(. Pull);
882
956
883
-
expect(res) |> toEqual([| Push(1), Push(2), End |]);
957
+
expect(res) |> toEqual([|Push(1), Push(2), End|]);
884
958
});
885
959
886
-
it("accepts the end of the source when max number of emissions is not reached", () => {
887
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
960
+
it(
961
+
"accepts the end of the source when max number of emissions is not reached",
962
+
() => {
963
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
888
964
let num = ref(1);
889
-
let notifier = sink => sink(.Start(Wonka_helpers.talkbackPlaceholder));
965
+
let notifier = sink =>
966
+
sink(. Start(Wonka_helpers.talkbackPlaceholder));
890
967
891
-
let source = Wonka.takeUntil(notifier, sink => sink(.Start((.signal) => {
892
-
switch (signal) {
893
-
| Pull => {
894
-
let i = num^;
895
-
if (num^ <= 2) {
896
-
num := num^ + 1;
897
-
sink(.Push(i));
898
-
} else {
899
-
sink(.End);
900
-
}
901
-
}
902
-
| _ => ()
903
-
}
904
-
})));
968
+
let source =
969
+
Wonka.takeUntil(notifier, sink =>
970
+
sink(.
971
+
Start(
972
+
(. signal) =>
973
+
switch (signal) {
974
+
| Pull =>
975
+
let i = num^;
976
+
if (num^ <= 2) {
977
+
num := num^ + 1;
978
+
sink(. Push(i));
979
+
} else {
980
+
sink(. End);
981
+
};
982
+
| _ => ()
983
+
},
984
+
),
985
+
)
986
+
);
905
987
906
988
let res = [||];
907
989
908
-
source((.signal) => {
990
+
source((. signal) =>
909
991
switch (signal) {
910
992
| Start(x) => talkback := x
911
993
| _ => ignore(Js.Array.push(signal, res))
912
994
}
913
-
});
995
+
);
914
996
915
-
talkback^(.Pull);
916
-
talkback^(.Pull);
917
-
talkback^(.Pull);
918
-
talkback^(.Pull);
997
+
talkback^(. Pull);
998
+
talkback^(. Pull);
999
+
talkback^(. Pull);
1000
+
talkback^(. Pull);
919
1001
920
-
expect(res) |> toEqual([| Push(1), Push(2), End |]);
1002
+
expect(res) |> toEqual([|Push(1), Push(2), End|]);
921
1003
});
922
1004
923
-
testPromise("follows the spec for listenables", () => {
1005
+
testPromise("follows the spec for listenables", () =>
924
1006
Wonka_thelpers.testWithListenable(Wonka.takeUntil(Wonka.never))
925
-
|> Js.Promise.then_(x => {
926
-
expect(x)
927
-
|> toEqual(([||], [| Push(1), Push(2), End |]))
928
-
|> Js.Promise.resolve
929
-
})
930
-
});
1007
+
|> Js.Promise.then_(x =>
1008
+
expect(x)
1009
+
|> toEqual(([||], [|Push(1), Push(2), End|]))
1010
+
|> Js.Promise.resolve
1011
+
)
1012
+
);
931
1013
932
1014
testPromise("follows the spec for listenables when ending the source", () => {
933
1015
let end_: talkbackT = Close;
934
1016
935
1017
Wonka_thelpers.testWithListenable(Wonka.takeUntil(Wonka.fromValue(0)))
936
-
|> Js.Promise.then_(x => {
937
-
expect(x)
938
-
|> toEqual(([| end_ |], [| End |]))
939
-
|> Js.Promise.resolve
940
-
})
1018
+
|> Js.Promise.then_(x =>
1019
+
expect(x) |> toEqual(([|end_|], [|End|])) |> Js.Promise.resolve
1020
+
);
941
1021
});
942
1022
943
-
testPromise("ends itself and source when its talkback receives the End signal", () => {
1023
+
testPromise(
1024
+
"ends itself and source when its talkback receives the End signal", () => {
944
1025
let end_: talkbackT = Close;
945
1026
946
1027
Wonka_thelpers.testTalkbackEnd(Wonka.takeUntil(Wonka.never))
947
-
|> Js.Promise.then_(x => {
948
-
expect(x)
949
-
|> toEqual(([| end_ |], [| Push(1) |]))
950
-
|> Js.Promise.resolve
951
-
})
1028
+
|> Js.Promise.then_(x =>
1029
+
expect(x)
1030
+
|> toEqual(([|end_|], [|Push(1)|]))
1031
+
|> Js.Promise.resolve
1032
+
);
952
1033
});
953
1034
});
954
1035
955
1036
describe("skip", () => {
956
1037
open Expect;
957
1038
958
-
it("only lets values through after a number of values have been filtered out", () => {
959
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
1039
+
it(
1040
+
"only lets values through after a number of values have been filtered out",
1041
+
() => {
1042
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
960
1043
let num = ref(1);
961
1044
962
-
let source = Wonka.skip(2, sink => sink(.Start((.signal) => {
963
-
switch (signal) {
964
-
| Pull when num^ <= 4 => {
965
-
let i = num^;
966
-
num := num^ + 1;
967
-
sink(.Push(i));
968
-
}
969
-
| Pull => sink(.End)
970
-
| _ => ()
971
-
}
972
-
})));
1045
+
let source =
1046
+
Wonka.skip(2, sink =>
1047
+
sink(.
1048
+
Start(
1049
+
(. signal) =>
1050
+
switch (signal) {
1051
+
| Pull when num^ <= 4 =>
1052
+
let i = num^;
1053
+
num := num^ + 1;
1054
+
sink(. Push(i));
1055
+
| Pull => sink(. End)
1056
+
| _ => ()
1057
+
},
1058
+
),
1059
+
)
1060
+
);
973
1061
974
1062
let res = [||];
975
1063
976
-
source((.signal) => {
1064
+
source((. signal) =>
977
1065
switch (signal) {
978
1066
| Start(x) => talkback := x
979
1067
| _ => ignore(Js.Array.push(signal, res))
980
1068
}
981
-
});
1069
+
);
982
1070
983
-
talkback^(.Pull);
984
-
talkback^(.Pull);
985
-
talkback^(.Pull);
986
-
expect(res) |> toEqual([| Push(3), Push(4), End |]);
1071
+
talkback^(. Pull);
1072
+
talkback^(. Pull);
1073
+
talkback^(. Pull);
1074
+
expect(res) |> toEqual([|Push(3), Push(4), End|]);
987
1075
});
988
1076
989
-
testPromise("follows the spec for listenables", () => {
1077
+
testPromise("follows the spec for listenables", () =>
990
1078
Wonka_thelpers.testWithListenable(Wonka.skip(0))
991
-
|> Js.Promise.then_(x => {
992
-
expect(x)
993
-
|> toEqual(([||], [| Push(1), Push(2), End |]))
994
-
|> Js.Promise.resolve
995
-
})
996
-
});
1079
+
|> Js.Promise.then_(x =>
1080
+
expect(x)
1081
+
|> toEqual(([||], [|Push(1), Push(2), End|]))
1082
+
|> Js.Promise.resolve
1083
+
)
1084
+
);
997
1085
998
-
testPromise("follows the spec for listenables when skipping the source", () => {
1086
+
testPromise(
1087
+
"follows the spec for listenables when skipping the source", () =>
999
1088
Wonka_thelpers.testWithListenable(Wonka.skip(10))
1000
-
|> Js.Promise.then_(x => {
1001
-
expect(x)
1002
-
|> toEqual(([| Pull, Pull |], [| End |]))
1003
-
|> Js.Promise.resolve
1004
-
})
1005
-
});
1089
+
|> Js.Promise.then_(x =>
1090
+
expect(x)
1091
+
|> toEqual(([|Pull, Pull|], [|End|]))
1092
+
|> Js.Promise.resolve
1093
+
)
1094
+
);
1006
1095
1007
-
testPromise("ends itself and source when its talkback receives the End signal", () => {
1096
+
testPromise(
1097
+
"ends itself and source when its talkback receives the End signal", () => {
1008
1098
let end_: talkbackT = Close;
1009
1099
1010
1100
Wonka_thelpers.testTalkbackEnd(Wonka.skip(10))
1011
-
|> Js.Promise.then_(x => {
1012
-
expect(x)
1013
-
|> toEqual(([| Pull, end_ |], [| |]))
1014
-
|> Js.Promise.resolve
1015
-
})
1101
+
|> Js.Promise.then_(x =>
1102
+
expect(x)
1103
+
|> toEqual(([|Pull, end_|], [||]))
1104
+
|> Js.Promise.resolve
1105
+
);
1016
1106
});
1017
1107
});
1018
1108
1019
1109
describe("skipWhile", () => {
1020
1110
open Expect;
1021
1111
1022
-
it("only lets values through after the predicate returned false, including the first such value", () => {
1023
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
1024
-
let num = ref(1);
1112
+
it(
1113
+
"only lets values through after the predicate returned false, including the first such value",
1114
+
() => {
1115
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
1116
+
let num = ref(1);
1025
1117
1026
-
let source = Wonka.skipWhile((.x) => x <= 2, sink => sink(.Start((.signal) => {
1027
-
switch (signal) {
1028
-
| Pull when num^ <= 4 => {
1029
-
let i = num^;
1030
-
num := num^ + 1;
1031
-
sink(.Push(i));
1032
-
}
1033
-
| Pull => sink(.End)
1034
-
| _ => ()
1035
-
}
1036
-
})));
1118
+
let source =
1119
+
Wonka.skipWhile(
1120
+
(. x) => x <= 2,
1121
+
sink =>
1122
+
sink(.
1123
+
Start(
1124
+
(. signal) =>
1125
+
switch (signal) {
1126
+
| Pull when num^ <= 4 =>
1127
+
let i = num^;
1128
+
num := num^ + 1;
1129
+
sink(. Push(i));
1130
+
| Pull => sink(. End)
1131
+
| _ => ()
1132
+
},
1133
+
),
1134
+
),
1135
+
);
1037
1136
1038
-
let res = [||];
1137
+
let res = [||];
1039
1138
1040
-
source((.signal) => {
1041
-
switch (signal) {
1042
-
| Start(x) => talkback := x
1043
-
| _ => ignore(Js.Array.push(signal, res))
1044
-
}
1045
-
});
1139
+
source((. signal) =>
1140
+
switch (signal) {
1141
+
| Start(x) => talkback := x
1142
+
| _ => ignore(Js.Array.push(signal, res))
1143
+
}
1144
+
);
1046
1145
1047
-
talkback^(.Pull);
1048
-
talkback^(.Pull);
1049
-
talkback^(.Pull);
1050
-
expect(res) |> toEqual([| Push(3), Push(4), End |]);
1051
-
});
1146
+
talkback^(. Pull);
1147
+
talkback^(. Pull);
1148
+
talkback^(. Pull);
1149
+
expect(res) |> toEqual([|Push(3), Push(4), End|]);
1150
+
},
1151
+
);
1052
1152
1053
-
testPromise("follows the spec for listenables", () => {
1054
-
Wonka_thelpers.testWithListenable(Wonka.skipWhile((._) => false))
1055
-
|> Js.Promise.then_(x => {
1056
-
expect(x)
1057
-
|> toEqual(([||], [| Push(1), Push(2), End |]))
1058
-
|> Js.Promise.resolve
1059
-
})
1060
-
});
1153
+
testPromise("follows the spec for listenables", () =>
1154
+
Wonka_thelpers.testWithListenable(Wonka.skipWhile((. _) => false))
1155
+
|> Js.Promise.then_(x =>
1156
+
expect(x)
1157
+
|> toEqual(([||], [|Push(1), Push(2), End|]))
1158
+
|> Js.Promise.resolve
1159
+
)
1160
+
);
1061
1161
1062
-
testPromise("follows the spec for listenables when skipping the source", () => {
1063
-
Wonka_thelpers.testWithListenable(Wonka.skipWhile((._) => true))
1064
-
|> Js.Promise.then_(x => {
1065
-
expect(x)
1066
-
|> toEqual(([| Pull, Pull |], [| End |]))
1067
-
|> Js.Promise.resolve
1068
-
})
1069
-
});
1162
+
testPromise(
1163
+
"follows the spec for listenables when skipping the source", () =>
1164
+
Wonka_thelpers.testWithListenable(Wonka.skipWhile((. _) => true))
1165
+
|> Js.Promise.then_(x =>
1166
+
expect(x)
1167
+
|> toEqual(([|Pull, Pull|], [|End|]))
1168
+
|> Js.Promise.resolve
1169
+
)
1170
+
);
1070
1171
1071
-
testPromise("ends itself and source when its talkback receives the End signal", () => {
1172
+
testPromise(
1173
+
"ends itself and source when its talkback receives the End signal", () => {
1072
1174
let end_: talkbackT = Close;
1073
1175
1074
-
Wonka_thelpers.testTalkbackEnd(Wonka.skipWhile((._) => false))
1075
-
|> Js.Promise.then_(x => {
1076
-
expect(x)
1077
-
|> toEqual(([| end_ |], [| Push(1) |]))
1078
-
|> Js.Promise.resolve
1079
-
})
1176
+
Wonka_thelpers.testTalkbackEnd(Wonka.skipWhile((. _) => false))
1177
+
|> Js.Promise.then_(x =>
1178
+
expect(x)
1179
+
|> toEqual(([|end_|], [|Push(1)|]))
1180
+
|> Js.Promise.resolve
1181
+
);
1080
1182
});
1081
1183
});
1082
1184
···
1084
1186
open Expect;
1085
1187
1086
1188
it("only lets values through after the notifier emits a value", () => {
1087
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
1189
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
1088
1190
let notify = ref((_: Wonka_types.talkbackT) => ());
1089
1191
let num = ref(1);
1090
1192
1091
1193
let notifier = sink => {
1092
-
notify := signal => switch (signal) {
1093
-
| Pull => sink(.Push(0));
1094
-
| _ => ()
1095
-
};
1194
+
notify :=
1195
+
(
1196
+
signal =>
1197
+
switch (signal) {
1198
+
| Pull => sink(. Push(0))
1199
+
| _ => ()
1200
+
}
1201
+
);
1096
1202
1097
-
sink(.Start(Wonka_helpers.talkbackPlaceholder));
1203
+
sink(. Start(Wonka_helpers.talkbackPlaceholder));
1098
1204
};
1099
1205
1100
-
let source = Wonka.skipUntil(notifier, (sink) => sink(.Start((.signal) => {
1101
-
switch (signal) {
1102
-
| Pull when num^ <= 4 => {
1103
-
let i = num^;
1104
-
if (i === 3) notify^(Pull);
1105
-
num := num^ + 1;
1106
-
sink(.Push(i));
1107
-
}
1108
-
| Pull => sink(.End)
1109
-
| _ => ()
1110
-
}
1111
-
})));
1206
+
let source =
1207
+
Wonka.skipUntil(notifier, sink =>
1208
+
sink(.
1209
+
Start(
1210
+
(. signal) =>
1211
+
switch (signal) {
1212
+
| Pull when num^ <= 4 =>
1213
+
let i = num^;
1214
+
if (i === 3) {
1215
+
notify^(Pull);
1216
+
};
1217
+
num := num^ + 1;
1218
+
sink(. Push(i));
1219
+
| Pull => sink(. End)
1220
+
| _ => ()
1221
+
},
1222
+
),
1223
+
)
1224
+
);
1112
1225
1113
1226
let res = [||];
1114
1227
1115
-
source((.signal) => {
1228
+
source((. signal) =>
1116
1229
switch (signal) {
1117
1230
| Start(x) => talkback := x
1118
1231
| _ => ignore(Js.Array.push(signal, res))
1119
1232
}
1120
-
});
1233
+
);
1121
1234
1122
-
talkback^(.Pull);
1123
-
talkback^(.Pull);
1124
-
talkback^(.Pull);
1125
-
talkback^(.Pull);
1235
+
talkback^(. Pull);
1236
+
talkback^(. Pull);
1237
+
talkback^(. Pull);
1238
+
talkback^(. Pull);
1126
1239
1127
-
expect(res) |> toEqual([| Push(3), Push(4), End |]);
1240
+
expect(res) |> toEqual([|Push(3), Push(4), End|]);
1128
1241
});
1129
1242
1130
-
it("accepts the end of the source when max number of emissions is not reached", () => {
1131
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
1243
+
it(
1244
+
"accepts the end of the source when max number of emissions is not reached",
1245
+
() => {
1246
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
1132
1247
let num = ref(1);
1133
-
let notifier = sink => sink(.Start(Wonka_helpers.talkbackPlaceholder));
1248
+
let notifier = sink =>
1249
+
sink(. Start(Wonka_helpers.talkbackPlaceholder));
1134
1250
1135
-
let source = Wonka.skipUntil(notifier, (sink) => sink(.Start((.signal) => {
1136
-
switch (signal) {
1137
-
| Pull => {
1138
-
let i = num^;
1139
-
if (i < 2) {
1140
-
num := num^ + 1;
1141
-
sink(.Push(i));
1142
-
} else {
1143
-
sink(.End);
1144
-
}
1145
-
}
1146
-
| _ => ()
1147
-
}
1148
-
})));
1251
+
let source =
1252
+
Wonka.skipUntil(notifier, sink =>
1253
+
sink(.
1254
+
Start(
1255
+
(. signal) =>
1256
+
switch (signal) {
1257
+
| Pull =>
1258
+
let i = num^;
1259
+
if (i < 2) {
1260
+
num := num^ + 1;
1261
+
sink(. Push(i));
1262
+
} else {
1263
+
sink(. End);
1264
+
};
1265
+
| _ => ()
1266
+
},
1267
+
),
1268
+
)
1269
+
);
1149
1270
1150
1271
let res = [||];
1151
1272
1152
-
source((.signal) => {
1273
+
source((. signal) =>
1153
1274
switch (signal) {
1154
1275
| Start(x) => talkback := x
1155
1276
| _ => ignore(Js.Array.push(signal, res))
1156
1277
}
1157
-
});
1278
+
);
1158
1279
1159
-
talkback^(.Pull);
1160
-
talkback^(.Pull);
1161
-
talkback^(.Pull);
1280
+
talkback^(. Pull);
1281
+
talkback^(. Pull);
1282
+
talkback^(. Pull);
1162
1283
1163
-
expect(res) |> toEqual([| End |]);
1284
+
expect(res) |> toEqual([|End|]);
1164
1285
});
1165
1286
1166
-
testPromise("follows the spec for listenables", () => {
1287
+
testPromise("follows the spec for listenables", () =>
1167
1288
Wonka_thelpers.testWithListenable(Wonka.skipUntil(Wonka.never))
1168
-
|> Js.Promise.then_(x => {
1169
-
expect(x)
1170
-
|> toEqual(([| Pull, Pull, Pull |], [| End |]))
1171
-
|> Js.Promise.resolve
1172
-
})
1173
-
});
1289
+
|> Js.Promise.then_(x =>
1290
+
expect(x)
1291
+
|> toEqual(([|Pull, Pull, Pull|], [|End|]))
1292
+
|> Js.Promise.resolve
1293
+
)
1294
+
);
1174
1295
1175
-
testPromise("follows the spec for listenables when skipping the source", () => {
1296
+
testPromise(
1297
+
"follows the spec for listenables when skipping the source", () =>
1176
1298
Wonka_thelpers.testWithListenable(Wonka.skipUntil(Wonka.fromValue(0)))
1177
-
|> Js.Promise.then_(x => {
1178
-
expect(x)
1179
-
|> toEqual(([| Pull |], [| Push(1), Push(2), End |]))
1180
-
|> Js.Promise.resolve
1181
-
})
1182
-
});
1299
+
|> Js.Promise.then_(x =>
1300
+
expect(x)
1301
+
|> toEqual(([|Pull|], [|Push(1), Push(2), End|]))
1302
+
|> Js.Promise.resolve
1303
+
)
1304
+
);
1183
1305
1184
-
testPromise("ends itself and source when its talkback receives the End signal", () => {
1306
+
testPromise(
1307
+
"ends itself and source when its talkback receives the End signal", () => {
1185
1308
let end_: talkbackT = Close;
1186
1309
1187
1310
Wonka_thelpers.testTalkbackEnd(Wonka.skipUntil(Wonka.fromValue(0)))
1188
-
|> Js.Promise.then_(x => {
1189
-
expect(x)
1190
-
|> toEqual(([| Pull, end_ |], [| Push(1) |]))
1191
-
|> Js.Promise.resolve
1192
-
})
1311
+
|> Js.Promise.then_(x =>
1312
+
expect(x)
1313
+
|> toEqual(([|Pull, end_|], [|Push(1)|]))
1314
+
|> Js.Promise.resolve
1315
+
);
1193
1316
});
1194
1317
});
1195
1318
1196
-
describe("flatten", () => {
1197
-
open Expect;
1319
+
describe("flatten", () =>
1320
+
Expect.(
1321
+
it("merges the result of multiple pullables into its source", () => {
1322
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
1323
+
let source =
1324
+
Wonka.fromList([Wonka.fromList([1, 2]), Wonka.fromList([1, 2])])
1325
+
|> Wonka.flatten;
1198
1326
1199
-
it("merges the result of multiple pullables into its source", () => {
1200
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
1201
-
let source = Wonka.fromList([ Wonka.fromList([ 1, 2 ]), Wonka.fromList([ 1, 2 ]) ])
1202
-
|> Wonka.flatten;
1327
+
let res = [||];
1203
1328
1204
-
let res = [||];
1329
+
source((. signal) =>
1330
+
switch (signal) {
1331
+
| Start(x) => talkback := x
1332
+
| _ => ignore(Js.Array.push(signal, res))
1333
+
}
1334
+
);
1205
1335
1206
-
source((.signal) => {
1207
-
switch (signal) {
1208
-
| Start(x) => talkback := x
1209
-
| _ => ignore(Js.Array.push(signal, res))
1210
-
}
1211
-
});
1212
-
1213
-
talkback^(.Pull);
1214
-
talkback^(.Pull);
1215
-
talkback^(.Pull);
1216
-
talkback^(.Pull);
1217
-
talkback^(.Pull);
1218
-
expect(res) |> toEqual([| Push(1), Push(2), Push(1), Push(2), End |]);
1219
-
});
1220
-
});
1336
+
talkback^(. Pull);
1337
+
talkback^(. Pull);
1338
+
talkback^(. Pull);
1339
+
talkback^(. Pull);
1340
+
talkback^(. Pull);
1341
+
expect(res)
1342
+
|> toEqual([|Push(1), Push(2), Push(1), Push(2), End|]);
1343
+
})
1344
+
)
1345
+
);
1221
1346
1222
1347
describe("switchMap", () => {
1223
1348
afterEach(() => Jest.useRealTimers());
1224
-
1225
1349
open Expect;
1226
1350
open! Expect.Operators;
1227
1351
···
1230
1354
1231
1355
let talkback = ref((. _: Wonka_types.talkbackT) => ());
1232
1356
let signals = [||];
1233
-
let source = Wonka.switchMap((.x) => Wonka.fromList([x * x]), a);
1357
+
let source = Wonka.switchMap((. x) => Wonka.fromList([x * x]), a);
1234
1358
1235
-
source((.signal) =>
1359
+
source((. signal) =>
1236
1360
switch (signal) {
1237
1361
| Start(x) =>
1238
1362
talkback := x;
1239
-
x(.Pull);
1363
+
x(. Pull);
1240
1364
| Push(_) =>
1241
1365
ignore(Js.Array.push(signal, signals));
1242
-
talkback^(.Pull);
1366
+
talkback^(. Pull);
1243
1367
| End => ignore(Js.Array.push(signal, signals))
1244
1368
}
1245
1369
);
···
1252
1376
1253
1377
let a = Wonka.interval(100);
1254
1378
1255
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
1379
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
1256
1380
let signals = [||];
1257
1381
let source =
1258
-
Wonka.switchMap((._) => Wonka.interval(25), a) |> Wonka.take(5);
1382
+
Wonka.switchMap((. _) => Wonka.interval(25), a) |> Wonka.take(5);
1259
1383
1260
-
source((.signal) =>
1384
+
source((. signal) =>
1261
1385
switch (signal) {
1262
1386
| Start(x) =>
1263
1387
talkback := x;
1264
-
x(.Pull);
1388
+
x(. Pull);
1265
1389
| Push(_) =>
1266
1390
ignore(Js.Array.push(signal, signals));
1267
-
talkback^(.Pull);
1391
+
talkback^(. Pull);
1268
1392
| End => ignore(Js.Array.push(signal, signals))
1269
1393
}
1270
1394
);
···
1277
1401
1278
1402
testPromise("follows the spec for listenables", () =>
1279
1403
Wonka_thelpers.testWithListenable(source =>
1280
-
Wonka.switchMap((.x) => x, Wonka.fromList([source]))
1404
+
Wonka.switchMap((. x) => x, Wonka.fromList([source]))
1281
1405
)
1282
1406
|> Js.Promise.then_(x =>
1283
1407
expect(x)
···
1289
1413
testPromise(
1290
1414
"ends itself and source when its talkback receives the End signal", () =>
1291
1415
Wonka_thelpers.testTalkbackEnd(source =>
1292
-
Wonka.switchMap((.x) => x, Wonka.fromList([source]))
1416
+
Wonka.switchMap((. x) => x, Wonka.fromList([source]))
1293
1417
)
1294
1418
|> Js.Promise.then_(x =>
1295
1419
expect(x)
···
1301
1425
});
1302
1426
1303
1427
describe("sink factories", () => {
1304
-
describe("forEach", () => {
1305
-
open Expect;
1428
+
describe("forEach", () =>
1429
+
Expect.(
1430
+
it("calls a function for each emission of the passed source", () => {
1431
+
let i = ref(0);
1432
+
let nums = [||];
1306
1433
1307
-
it("calls a function for each emission of the passed source", () => {
1308
-
let i = ref(0);
1309
-
let nums = [||];
1434
+
let source = sink => {
1435
+
sink(.
1436
+
Start(
1437
+
(. signal) =>
1438
+
switch (signal) {
1439
+
| Pull when i^ < 4 =>
1440
+
let num = i^;
1441
+
i := i^ + 1;
1442
+
sink(. Push(num));
1443
+
| Pull => sink(. End)
1444
+
| _ => ()
1445
+
},
1446
+
),
1447
+
);
1448
+
};
1310
1449
1311
-
let source = sink => {
1312
-
sink(.Start((.signal) => {
1313
-
switch (signal) {
1314
-
| Pull when i^ < 4 => {
1315
-
let num = i^;
1316
-
i := i^ + 1;
1317
-
sink(.Push(num));
1318
-
}
1319
-
| Pull => sink(.End)
1320
-
| _ => ()
1321
-
}
1322
-
}));
1323
-
};
1450
+
Wonka.forEach((. x) => ignore(Js.Array.push(x, nums)), source);
1451
+
expect(nums) |> toEqual([|0, 1, 2, 3|]);
1452
+
})
1453
+
)
1454
+
);
1324
1455
1325
-
Wonka.forEach((.x) => ignore(Js.Array.push(x, nums)), source);
1326
-
expect(nums) |> toEqual([| 0, 1, 2, 3 |])
1327
-
});
1328
-
});
1456
+
describe("subscribe", () =>
1457
+
Expect.(
1458
+
it(
1459
+
"calls a function for each emission of the passed source and stops when unsubscribed",
1460
+
() => {
1461
+
let i = ref(0);
1462
+
let nums = [||];
1463
+
let push = ref(() => ());
1329
1464
1330
-
describe("subscribe", () => {
1331
-
open Expect;
1465
+
let source = sink => {
1466
+
push :=
1467
+
(
1468
+
() => {
1469
+
let num = i^;
1470
+
i := i^ + 1;
1471
+
sink(. Push(num));
1472
+
}
1473
+
);
1332
1474
1333
-
it("calls a function for each emission of the passed source and stops when unsubscribed", () => {
1334
-
let i = ref(0);
1335
-
let nums = [||];
1336
-
let push = ref(() => ());
1337
-
1338
-
let source = sink => {
1339
-
push := () => {
1340
-
let num = i^;
1341
-
i := i^ + 1;
1342
-
sink(.Push(num));
1343
-
};
1475
+
sink(. Start(Wonka_helpers.talkbackPlaceholder));
1476
+
};
1344
1477
1345
-
sink(.Start(Wonka_helpers.talkbackPlaceholder));
1346
-
};
1478
+
let {unsubscribe} =
1479
+
Wonka.subscribe(
1480
+
(. x) => ignore(Js.Array.push(x, nums)),
1481
+
source,
1482
+
);
1347
1483
1348
-
let { unsubscribe } = Wonka.subscribe((.x) => ignore(Js.Array.push(x, nums)), source);
1484
+
push^();
1485
+
push^();
1486
+
unsubscribe();
1487
+
push^();
1488
+
push^();
1349
1489
1350
-
push^();
1351
-
push^();
1352
-
unsubscribe();
1353
-
push^();
1354
-
push^();
1355
-
1356
-
expect(nums) |> toEqual([| 0, 1 |])
1357
-
});
1358
-
});
1490
+
expect(nums) |> toEqual([|0, 1|]);
1491
+
},
1492
+
)
1493
+
)
1494
+
);
1359
1495
});
1360
1496
1361
-
describe("chains (integration)", () => {
1362
-
open Expect;
1497
+
describe("chains (integration)", () =>
1498
+
Expect.(
1499
+
it("fromArray, map, forEach", () => {
1500
+
let input = Array.mapi((i, _) => i, Array.make(1000, 1));
1501
+
let output = Array.map(x => string_of_int(x));
1502
+
let actual = [||];
1363
1503
1364
-
it("fromArray, map, forEach", () => {
1365
-
let input = Array.mapi((i, _) => i, Array.make(1000, 1));
1366
-
let output = Array.map(x => string_of_int(x));
1367
-
let actual = [||];
1368
-
1369
-
input
1504
+
input
1370
1505
|> Wonka.fromArray
1371
-
|> Wonka.map((.x) => string_of_int(x))
1372
-
|> Wonka.forEach((.x) => ignore(Js.Array.push(x, actual)));
1506
+
|> Wonka.map((. x) => string_of_int(x))
1507
+
|> Wonka.forEach((. x) => ignore(Js.Array.push(x, actual)));
1373
1508
1374
-
expect(output) |> toEqual(output)
1375
-
});
1376
-
});
1509
+
expect(output) |> toEqual(output);
1510
+
})
1511
+
)
1512
+
);
1377
1513
1378
1514
describe("subject", () => {
1379
1515
open Expect;
···
1384
1520
1385
1521
let subject = Wonka.makeSubject();
1386
1522
1387
-
subject.source((.signal) =>
1523
+
subject.source((. signal) =>
1388
1524
switch (signal) {
1389
1525
| Start(_) => ignore()
1390
1526
| Push(_) => ignore(Js.Array.push(signal, signals))
···
1402
1538
});
1403
1539
1404
1540
it("handles multiple sinks", () => {
1405
-
let talkback = ref((._: Wonka_types.talkbackT) => ());
1541
+
let talkback = ref((. _: Wonka_types.talkbackT) => ());
1406
1542
let signalsOne = [||];
1407
1543
let signalsTwo = [||];
1408
1544
1409
1545
let subject = Wonka.makeSubject();
1410
1546
1411
-
subject.source((.signal) =>
1547
+
subject.source((. signal) =>
1412
1548
switch (signal) {
1413
1549
| Start(x) => talkback := x
1414
1550
| Push(_) => ignore(Js.Array.push(signal, signalsOne))
···
1416
1552
}
1417
1553
);
1418
1554
1419
-
subject.source((.signal) =>
1555
+
subject.source((. signal) =>
1420
1556
switch (signal) {
1421
1557
| Start(_) => ignore()
1422
1558
| Push(_) => ignore(Js.Array.push(signal, signalsTwo))
···
1428
1564
subject.next(20);
1429
1565
subject.next(30);
1430
1566
1431
-
talkback^(.Close);
1567
+
talkback^(. Close);
1432
1568
1433
1569
subject.next(40);
1434
1570
subject.next(50);
···
1443
1579
});
1444
1580
1445
1581
it("handles multiple sinks that subscribe and close at different times", () => {
1446
-
let talkbackOne = ref((._: Wonka_types.talkbackT) => ());
1447
-
let talkbackTwo = ref((._: Wonka_types.talkbackT) => ());
1582
+
let talkbackOne = ref((. _: Wonka_types.talkbackT) => ());
1583
+
let talkbackTwo = ref((. _: Wonka_types.talkbackT) => ());
1448
1584
let signalsOne = [||];
1449
1585
let signalsTwo = [||];
1450
1586
···
1453
1589
subject.next(10);
1454
1590
subject.next(20);
1455
1591
1456
-
subject.source((.signal) =>
1592
+
subject.source((. signal) =>
1457
1593
switch (signal) {
1458
1594
| Start(x) => talkbackOne := x
1459
1595
| Push(_) => ignore(Js.Array.push(signal, signalsOne))
···
1463
1599
1464
1600
subject.next(30);
1465
1601
1466
-
subject.source((.signal) =>
1602
+
subject.source((. signal) =>
1467
1603
switch (signal) {
1468
1604
| Start(x) => talkbackTwo := x
1469
1605
| Push(_) => ignore(Js.Array.push(signal, signalsTwo))
···
1474
1610
subject.next(40);
1475
1611
subject.next(50);
1476
1612
1477
-
talkbackTwo^(.Close);
1613
+
talkbackTwo^(. Close);
1478
1614
1479
1615
subject.next(60);
1480
1616
1481
-
talkbackOne^(.Close);
1617
+
talkbackOne^(. Close);
1482
1618
1483
1619
subject.next(70);
1484
1620
subject.complete();
+42
-31
__tests__/wonka_thelpers.re
+42
-31
__tests__/wonka_thelpers.re
···
1
1
open Wonka_types;
2
2
3
3
let testWithListenable = operator => {
4
-
let sink = ref((._: signalT(int)) => ());
4
+
let sink = ref((. _: signalT(int)) => ());
5
5
let signals = [||];
6
6
let source = x => {
7
7
sink := x;
8
-
x(.Start((.signal) => {
9
-
ignore(Js.Array.push(signal, signals))
10
-
}));
8
+
x(. Start((. signal) => ignore(Js.Array.push(signal, signals))));
11
9
};
12
10
13
-
let talkback = ref((._: talkbackT) => ());
11
+
let talkback = ref((. _: talkbackT) => ());
14
12
let res = [||];
15
-
operator(source)((.signal) => {
13
+
operator(source, (. signal) =>
16
14
switch (signal) {
17
15
| Start(x) => talkback := x
18
16
| _ => ignore(Js.Array.push(signal, res))
19
17
}
20
-
});
18
+
);
21
19
22
20
Js.Promise.make((~resolve, ~reject as _) => {
23
-
sink^(.Push(1));
24
-
ignore(Js.Global.setTimeout(() => {
25
-
sink^(.Push(2));
26
-
ignore(Js.Global.setTimeout(() => {
27
-
sink^(.End);
28
-
ignore(Js.Global.setTimeout(() => {
29
-
resolve(.(signals, res));
30
-
}, 0));
31
-
}, 0));
32
-
}, 0));
33
-
})
21
+
sink^(. Push(1));
22
+
ignore(
23
+
Js.Global.setTimeout(
24
+
() => {
25
+
sink^(. Push(2));
26
+
ignore(
27
+
Js.Global.setTimeout(
28
+
() => {
29
+
sink^(. End);
30
+
ignore(
31
+
Js.Global.setTimeout(() => resolve(. (signals, res)), 0),
32
+
);
33
+
},
34
+
0,
35
+
),
36
+
);
37
+
},
38
+
0,
39
+
),
40
+
);
41
+
});
34
42
};
35
43
36
44
let testTalkbackEnd = operator => {
37
-
let sink = ref((._: signalT(int)) => ());
45
+
let sink = ref((. _: signalT(int)) => ());
38
46
let signals: array(talkbackT) = [||];
39
47
let source = x => {
40
-
x(.Start((.signal) => ignore(Js.Array.push(signal, signals))));
48
+
x(. Start((. signal) => ignore(Js.Array.push(signal, signals))));
41
49
sink := x;
42
50
};
43
51
44
-
let talkback = ref((._: talkbackT) => ());
52
+
let talkback = ref((. _: talkbackT) => ());
45
53
let res = [||];
46
-
operator(source)((.signal) => {
54
+
operator(source, (. signal) =>
47
55
switch (signal) {
48
56
| Start(x) => talkback := x
49
57
| _ => ignore(Js.Array.push(signal, res))
50
58
}
51
-
});
59
+
);
52
60
53
61
Js.Promise.make((~resolve, ~reject as _) => {
54
-
sink^(.Push(1));
55
-
ignore(Js.Global.setTimeout(() => {
56
-
talkback^(.Close);
57
-
ignore(Js.Global.setTimeout(() => {
58
-
resolve(.(signals, res));
59
-
}, 0));
60
-
}, 0));
61
-
})
62
+
sink^(. Push(1));
63
+
ignore(
64
+
Js.Global.setTimeout(
65
+
() => {
66
+
talkback^(. Close);
67
+
ignore(Js.Global.setTimeout(() => resolve(. (signals, res)), 0));
68
+
},
69
+
0,
70
+
),
71
+
);
72
+
});
62
73
};
+14
package.json
+14
package.json
···
26
26
"terser:cjs": "terser --config-file .terser.config.json -o ./dist/wonka.js ./dist/wonka.js",
27
27
"terser": "run-p terser:es terser:cjs",
28
28
"prettier": "prettier --write ./dist/*.js",
29
+
"refmt": "bsrefmt --in-place **/**/*.re",
29
30
"prebundle": "rimraf ./dist",
30
31
"bundle": "microbundle --external none --no-compress --no-sourcemap --format es,cjs",
31
32
"postbundle": "run-s terser prettier",
···
55
56
"bs-platform": "^4.0.17",
56
57
"bundlesize": "^0.17.0",
57
58
"coveralls": "^3.0.0",
59
+
"husky": "^1.3.1",
60
+
"lint-staged": "^8.1.5",
58
61
"microbundle": "^0.9.0",
59
62
"npm-run-all": "^4.1.5",
60
63
"prettier": "^1.15.3",
61
64
"rimraf": "^2.6.3",
62
65
"terser": "^3.14.1"
66
+
},
67
+
"lint-staged": {
68
+
"*.re": [
69
+
"bsrefmt --in-place",
70
+
"git add"
71
+
]
72
+
},
73
+
"husky": {
74
+
"hooks": {
75
+
"pre-commit": "lint-staged"
76
+
}
63
77
},
64
78
"prettier": {
65
79
"printWidth": 100
+70
-72
src/operators/wonka_operator_combine.re
+70
-72
src/operators/wonka_operator_combine.re
···
2
2
open Wonka_helpers;
3
3
4
4
type combineStateT('a, 'b) = {
5
-
mutable talkbackA: (.talkbackT) => unit,
6
-
mutable talkbackB: (.talkbackT) => unit,
5
+
mutable talkbackA: (. talkbackT) => unit,
6
+
mutable talkbackB: (. talkbackT) => unit,
7
7
mutable lastValA: option('a),
8
8
mutable lastValB: option('b),
9
9
mutable gotSignal: bool,
···
11
11
mutable ended: bool,
12
12
};
13
13
14
-
let combine = sourceA => curry(sourceB => curry(sink => {
15
-
let state = {
16
-
talkbackA: talkbackPlaceholder,
17
-
talkbackB: talkbackPlaceholder,
18
-
lastValA: None,
19
-
lastValB: None,
20
-
gotSignal: false,
21
-
endCounter: 0,
22
-
ended: false
23
-
};
14
+
let combine = sourceA =>
15
+
curry(sourceB =>
16
+
curry(sink => {
17
+
let state = {
18
+
talkbackA: talkbackPlaceholder,
19
+
talkbackB: talkbackPlaceholder,
20
+
lastValA: None,
21
+
lastValB: None,
22
+
gotSignal: false,
23
+
endCounter: 0,
24
+
ended: false,
25
+
};
24
26
25
-
sourceA((.signal) => {
26
-
switch (signal, state.lastValB) {
27
-
| (Start(tb), _) => state.talkbackA = tb
28
-
| (Push(a), None) => {
29
-
state.lastValA = Some(a);
30
-
state.gotSignal = false;
31
-
}
32
-
| (Push(a), Some(b)) when !state.ended => {
33
-
state.lastValA = Some(a);
34
-
state.gotSignal = false;
35
-
sink(.Push((a, b)));
36
-
}
37
-
| (End, _) when state.endCounter < 1 =>
38
-
state.endCounter = state.endCounter + 1
39
-
| (End, _) when !state.ended => {
40
-
state.ended = true;
41
-
sink(.End);
42
-
}
43
-
| _ => ()
44
-
}
45
-
});
27
+
sourceA((. signal) =>
28
+
switch (signal, state.lastValB) {
29
+
| (Start(tb), _) => state.talkbackA = tb
30
+
| (Push(a), None) =>
31
+
state.lastValA = Some(a);
32
+
state.gotSignal = false;
33
+
| (Push(a), Some(b)) when !state.ended =>
34
+
state.lastValA = Some(a);
35
+
state.gotSignal = false;
36
+
sink(. Push((a, b)));
37
+
| (End, _) when state.endCounter < 1 =>
38
+
state.endCounter = state.endCounter + 1
39
+
| (End, _) when !state.ended =>
40
+
state.ended = true;
41
+
sink(. End);
42
+
| _ => ()
43
+
}
44
+
);
46
45
47
-
sourceB((.signal) => {
48
-
switch (signal, state.lastValA) {
49
-
| (Start(tb), _) => state.talkbackB = tb
50
-
| (Push(b), None) => {
51
-
state.lastValB = Some(b);
52
-
state.gotSignal = false;
53
-
}
54
-
| (Push(b), Some(a)) when !state.ended => {
55
-
state.lastValB = Some(b);
56
-
state.gotSignal = false;
57
-
sink(.Push((a, b)));
58
-
}
59
-
| (End, _) when state.endCounter < 1 =>
60
-
state.endCounter = state.endCounter + 1
61
-
| (End, _) when !state.ended => {
62
-
state.ended = true;
63
-
sink(.End);
64
-
}
65
-
| _ => ()
66
-
}
67
-
});
46
+
sourceB((. signal) =>
47
+
switch (signal, state.lastValA) {
48
+
| (Start(tb), _) => state.talkbackB = tb
49
+
| (Push(b), None) =>
50
+
state.lastValB = Some(b);
51
+
state.gotSignal = false;
52
+
| (Push(b), Some(a)) when !state.ended =>
53
+
state.lastValB = Some(b);
54
+
state.gotSignal = false;
55
+
sink(. Push((a, b)));
56
+
| (End, _) when state.endCounter < 1 =>
57
+
state.endCounter = state.endCounter + 1
58
+
| (End, _) when !state.ended =>
59
+
state.ended = true;
60
+
sink(. End);
61
+
| _ => ()
62
+
}
63
+
);
68
64
69
-
sink(.Start((.signal) => {
70
-
if (!state.ended) {
71
-
switch (signal) {
72
-
| Close => {
73
-
state.ended = true;
74
-
state.talkbackA(.Close);
75
-
state.talkbackB(.Close);
76
-
}
77
-
| Pull when !state.gotSignal => {
78
-
state.gotSignal = true;
79
-
state.talkbackA(.signal);
80
-
state.talkbackB(.signal);
81
-
}
82
-
| Pull => ()
83
-
}
84
-
};
85
-
}));
86
-
}));
65
+
sink(.
66
+
Start(
67
+
(. signal) =>
68
+
if (!state.ended) {
69
+
switch (signal) {
70
+
| Close =>
71
+
state.ended = true;
72
+
state.talkbackA(. Close);
73
+
state.talkbackB(. Close);
74
+
| Pull when !state.gotSignal =>
75
+
state.gotSignal = true;
76
+
state.talkbackA(. signal);
77
+
state.talkbackB(. signal);
78
+
| Pull => ()
79
+
};
80
+
},
81
+
),
82
+
);
83
+
})
84
+
);
+80
-78
src/operators/wonka_operator_concatMap.re
+80
-78
src/operators/wonka_operator_concatMap.re
···
3
3
4
4
type concatMapStateT('a) = {
5
5
inputQueue: Rebel.MutableQueue.t('a),
6
-
mutable outerTalkback: (.talkbackT) => unit,
7
-
mutable innerTalkback: (.talkbackT) => unit,
6
+
mutable outerTalkback: (. talkbackT) => unit,
7
+
mutable innerTalkback: (. talkbackT) => unit,
8
8
mutable innerActive: bool,
9
9
mutable closed: bool,
10
-
mutable ended: bool
10
+
mutable ended: bool,
11
11
};
12
12
13
-
let concatMap = f => curry(source => curry(sink => {
14
-
let state: concatMapStateT('a) = {
15
-
inputQueue: Rebel.MutableQueue.make(),
16
-
outerTalkback: talkbackPlaceholder,
17
-
innerTalkback: talkbackPlaceholder,
18
-
innerActive: false,
19
-
closed: false,
20
-
ended: false
21
-
};
13
+
let concatMap = f =>
14
+
curry(source =>
15
+
curry(sink => {
16
+
let state: concatMapStateT('a) = {
17
+
inputQueue: Rebel.MutableQueue.make(),
18
+
outerTalkback: talkbackPlaceholder,
19
+
innerTalkback: talkbackPlaceholder,
20
+
innerActive: false,
21
+
closed: false,
22
+
ended: false,
23
+
};
22
24
23
-
let rec applyInnerSource = innerSource =>
24
-
innerSource((.signal) => {
25
-
switch (signal) {
26
-
| End => {
27
-
state.innerActive = false;
28
-
state.innerTalkback = talkbackPlaceholder;
25
+
let rec applyInnerSource = innerSource =>
26
+
innerSource((. signal) =>
27
+
switch (signal) {
28
+
| End =>
29
+
state.innerActive = false;
30
+
state.innerTalkback = talkbackPlaceholder;
29
31
30
-
switch (Rebel.MutableQueue.pop(state.inputQueue)) {
31
-
| Some(input) => applyInnerSource(f(.input))
32
-
| None when state.ended => sink(.End)
33
-
| None => ()
34
-
};
35
-
}
36
-
| Start(tb) => {
37
-
state.innerActive = true;
38
-
state.innerTalkback = tb;
39
-
tb(.Pull);
40
-
}
41
-
| Push(x) when !state.closed => {
42
-
sink(.Push(x));
43
-
state.innerTalkback(.Pull);
44
-
}
45
-
| Push(_) => ()
46
-
}
47
-
});
32
+
switch (Rebel.MutableQueue.pop(state.inputQueue)) {
33
+
| Some(input) => applyInnerSource(f(. input))
34
+
| None when state.ended => sink(. End)
35
+
| None => ()
36
+
};
37
+
| Start(tb) =>
38
+
state.innerActive = true;
39
+
state.innerTalkback = tb;
40
+
tb(. Pull);
41
+
| Push(x) when !state.closed =>
42
+
sink(. Push(x));
43
+
state.innerTalkback(. Pull);
44
+
| Push(_) => ()
45
+
}
46
+
);
48
47
49
-
source((.signal) => {
50
-
switch (signal) {
51
-
| End when !state.ended => {
52
-
state.ended = true;
53
-
if (!state.innerActive && Rebel.MutableQueue.isEmpty(state.inputQueue)) {
54
-
sink(.End);
55
-
}
56
-
}
57
-
| End => ()
58
-
| Start(tb) => {
59
-
state.outerTalkback = tb;
60
-
tb(.Pull);
61
-
}
62
-
| Push(x) when !state.ended => {
63
-
if (state.innerActive) {
64
-
Rebel.MutableQueue.add(state.inputQueue, x);
65
-
} else {
66
-
applyInnerSource(f(.x));
67
-
}
48
+
source((. signal) =>
49
+
switch (signal) {
50
+
| End when !state.ended =>
51
+
state.ended = true;
52
+
if (!state.innerActive
53
+
&& Rebel.MutableQueue.isEmpty(state.inputQueue)) {
54
+
sink(. End);
55
+
};
56
+
| End => ()
57
+
| Start(tb) =>
58
+
state.outerTalkback = tb;
59
+
tb(. Pull);
60
+
| Push(x) when !state.ended =>
61
+
if (state.innerActive) {
62
+
Rebel.MutableQueue.add(state.inputQueue, x);
63
+
} else {
64
+
applyInnerSource(f(. x));
65
+
};
68
66
69
-
state.outerTalkback(.Pull);
70
-
}
71
-
| Push(_) => ()
72
-
}
73
-
});
67
+
state.outerTalkback(. Pull);
68
+
| Push(_) => ()
69
+
}
70
+
);
74
71
75
-
sink(.Start((.signal) => {
76
-
switch (signal) {
77
-
| Pull => if (!state.ended) state.innerTalkback(.Pull)
78
-
| Close => {
79
-
state.innerTalkback(.Close);
80
-
if (!state.ended) {
81
-
state.ended = true;
82
-
state.closed = true;
83
-
state.outerTalkback(.Close);
84
-
state.innerTalkback = talkbackPlaceholder;
85
-
}
86
-
}
87
-
}
88
-
}));
89
-
}));
72
+
sink(.
73
+
Start(
74
+
(. signal) =>
75
+
switch (signal) {
76
+
| Pull =>
77
+
if (!state.ended) {
78
+
state.innerTalkback(. Pull);
79
+
}
80
+
| Close =>
81
+
state.innerTalkback(. Close);
82
+
if (!state.ended) {
83
+
state.ended = true;
84
+
state.closed = true;
85
+
state.outerTalkback(. Close);
86
+
state.innerTalkback = talkbackPlaceholder;
87
+
};
88
+
},
89
+
),
90
+
);
91
+
})
92
+
);
90
93
91
-
let concatAll = source => concatMap((.x) => x, source);
94
+
let concatAll = source => concatMap((. x) => x, source);
92
95
93
96
let concat = sources => {
94
-
open Wonka_source_fromArray;
95
-
concatMap((.x) => x, fromArray(sources));
97
+
Wonka_source_fromArray.(concatMap((. x) => x, fromArray(sources)));
96
98
};
+11
-8
src/operators/wonka_operator_filter.re
+11
-8
src/operators/wonka_operator_filter.re
···
1
1
open Wonka_types;
2
2
open Wonka_helpers;
3
3
4
-
let filter = f => curry(source => curry(sink => {
5
-
captureTalkback(source, (.signal, talkback) => {
6
-
switch (signal) {
7
-
| Push(x) when !f(.x) => talkback(.Pull)
8
-
| _ => sink(.signal)
9
-
}
10
-
});
11
-
}));
4
+
let filter = f =>
5
+
curry(source =>
6
+
curry(sink =>
7
+
captureTalkback(source, (. signal, talkback) =>
8
+
switch (signal) {
9
+
| Push(x) when !f(. x) => talkback(. Pull)
10
+
| _ => sink(. signal)
11
+
}
12
+
)
13
+
)
14
+
);
+14
-9
src/operators/wonka_operator_map.re
+14
-9
src/operators/wonka_operator_map.re
···
1
1
open Wonka_types;
2
2
3
-
let map = f => curry(source => curry(sink => {
4
-
source((.signal) => sink(.
5
-
switch (signal) {
6
-
| Start(x) => Start(x)
7
-
| Push(x) => Push(f(.x))
8
-
| End => End
9
-
}
10
-
));
11
-
}));
3
+
let map = f =>
4
+
curry(source =>
5
+
curry(sink =>
6
+
source((. signal) =>
7
+
sink(.
8
+
switch (signal) {
9
+
| Start(x) => Start(x)
10
+
| Push(x) => Push(f(. x))
11
+
| End => End
12
+
},
13
+
)
14
+
)
15
+
)
16
+
);
+78
-72
src/operators/wonka_operator_mergeMap.re
+78
-72
src/operators/wonka_operator_mergeMap.re
···
2
2
open Wonka_helpers;
3
3
4
4
type mergeMapStateT = {
5
-
mutable outerTalkback: (.talkbackT) => unit,
6
-
mutable innerTalkbacks: Rebel.Array.t((.talkbackT) => unit),
7
-
mutable ended: bool
5
+
mutable outerTalkback: (. talkbackT) => unit,
6
+
mutable innerTalkbacks: Rebel.Array.t((. talkbackT) => unit),
7
+
mutable ended: bool,
8
8
};
9
9
10
-
let mergeMap = f => curry(source => curry(sink => {
11
-
let state: mergeMapStateT = {
12
-
outerTalkback: talkbackPlaceholder,
13
-
innerTalkbacks: Rebel.Array.makeEmpty(),
14
-
ended: false
15
-
};
10
+
let mergeMap = f =>
11
+
curry(source =>
12
+
curry(sink => {
13
+
let state: mergeMapStateT = {
14
+
outerTalkback: talkbackPlaceholder,
15
+
innerTalkbacks: Rebel.Array.makeEmpty(),
16
+
ended: false,
17
+
};
16
18
17
-
let applyInnerSource = innerSource => {
18
-
let talkback = ref(talkbackPlaceholder);
19
+
let applyInnerSource = innerSource => {
20
+
let talkback = ref(talkbackPlaceholder);
19
21
20
-
innerSource((.signal) => {
21
-
switch (signal) {
22
-
| End => {
23
-
state.innerTalkbacks = Rebel.Array.filter(state.innerTalkbacks, x => x !== talkback^);
24
-
if (state.ended && Rebel.Array.size(state.innerTalkbacks) === 0) {
25
-
sink(.End);
26
-
}
27
-
}
28
-
| Start(tb) => {
29
-
talkback := tb;
30
-
state.innerTalkbacks = Rebel.Array.append(state.innerTalkbacks, tb);
31
-
tb(.Pull);
32
-
}
33
-
| Push(x) when Rebel.Array.size(state.innerTalkbacks) !== 0 => {
34
-
sink(.Push(x));
35
-
talkback^(.Pull);
36
-
}
37
-
| Push(_) => ()
38
-
}
39
-
});
40
-
};
22
+
innerSource((. signal) =>
23
+
switch (signal) {
24
+
| End =>
25
+
state.innerTalkbacks =
26
+
Rebel.Array.filter(state.innerTalkbacks, x => x !== talkback^);
27
+
if (state.ended && Rebel.Array.size(state.innerTalkbacks) === 0) {
28
+
sink(. End);
29
+
};
30
+
| Start(tb) =>
31
+
talkback := tb;
32
+
state.innerTalkbacks =
33
+
Rebel.Array.append(state.innerTalkbacks, tb);
34
+
tb(. Pull);
35
+
| Push(x) when Rebel.Array.size(state.innerTalkbacks) !== 0 =>
36
+
sink(. Push(x));
37
+
talkback^(. Pull);
38
+
| Push(_) => ()
39
+
}
40
+
);
41
+
};
41
42
42
-
source((.signal) => {
43
-
switch (signal) {
44
-
| End when !state.ended => {
45
-
state.ended = true;
46
-
if (Rebel.Array.size(state.innerTalkbacks) === 0) {
47
-
sink(.End);
48
-
}
49
-
}
50
-
| End => ()
51
-
| Start(tb) => {
52
-
state.outerTalkback = tb;
53
-
tb(.Pull);
54
-
}
55
-
| Push(x) when !state.ended => {
56
-
applyInnerSource(f(.x));
57
-
state.outerTalkback(.Pull);
58
-
}
59
-
| Push(_) => ()
60
-
}
61
-
});
43
+
source((. signal) =>
44
+
switch (signal) {
45
+
| End when !state.ended =>
46
+
state.ended = true;
47
+
if (Rebel.Array.size(state.innerTalkbacks) === 0) {
48
+
sink(. End);
49
+
};
50
+
| End => ()
51
+
| Start(tb) =>
52
+
state.outerTalkback = tb;
53
+
tb(. Pull);
54
+
| Push(x) when !state.ended =>
55
+
applyInnerSource(f(. x));
56
+
state.outerTalkback(. Pull);
57
+
| Push(_) => ()
58
+
}
59
+
);
62
60
63
-
sink(.Start((.signal) => {
64
-
switch (signal) {
65
-
| Close => {
66
-
Rebel.Array.forEach(state.innerTalkbacks, talkback => talkback(.Close));
67
-
if (!state.ended) {
68
-
state.ended = true;
69
-
state.outerTalkback(.Close);
70
-
Rebel.Array.forEach(state.innerTalkbacks, talkback => talkback(.Close));
71
-
state.innerTalkbacks = Rebel.Array.makeEmpty();
72
-
}
73
-
}
74
-
| Pull when !state.ended =>
75
-
Rebel.Array.forEach(state.innerTalkbacks, talkback => talkback(.Pull));
76
-
| Pull => ()
77
-
}
78
-
}));
79
-
}));
61
+
sink(.
62
+
Start(
63
+
(. signal) =>
64
+
switch (signal) {
65
+
| Close =>
66
+
Rebel.Array.forEach(state.innerTalkbacks, talkback =>
67
+
talkback(. Close)
68
+
);
69
+
if (!state.ended) {
70
+
state.ended = true;
71
+
state.outerTalkback(. Close);
72
+
Rebel.Array.forEach(state.innerTalkbacks, talkback =>
73
+
talkback(. Close)
74
+
);
75
+
state.innerTalkbacks = Rebel.Array.makeEmpty();
76
+
};
77
+
| Pull when !state.ended =>
78
+
Rebel.Array.forEach(state.innerTalkbacks, talkback =>
79
+
talkback(. Pull)
80
+
)
81
+
| Pull => ()
82
+
},
83
+
),
84
+
);
85
+
})
86
+
);
80
87
81
88
let merge = sources => {
82
-
open Wonka_source_fromArray;
83
-
mergeMap((.x) => x, fromArray(sources));
89
+
Wonka_source_fromArray.(mergeMap((. x) => x, fromArray(sources)));
84
90
};
85
91
86
-
let mergeAll = source => mergeMap((.x) => x, source);
92
+
let mergeAll = source => mergeMap((. x) => x, source);
87
93
let flatten = mergeAll;
+28
-25
src/operators/wonka_operator_onEnd.re
+28
-25
src/operators/wonka_operator_onEnd.re
···
1
1
open Wonka_types;
2
2
3
-
let onEnd = f => curry(source => curry(sink => {
4
-
let ended = ref(false);
3
+
let onEnd = f =>
4
+
curry(source =>
5
+
curry(sink => {
6
+
let ended = ref(false);
5
7
6
-
source((.signal) => {
7
-
switch (signal) {
8
-
| Start(talkback) => {
9
-
sink(.Start((.signal) => {
8
+
source((. signal) =>
10
9
switch (signal) {
11
-
| Close when !ended^ => {
12
-
ended := true;
13
-
f(.);
10
+
| Start(talkback) =>
11
+
sink(.
12
+
Start(
13
+
(. signal) =>
14
+
switch (signal) {
15
+
| Close when ! ended^ =>
16
+
ended := true;
17
+
f(.);
18
+
| Close => ()
19
+
| Pull => talkback(. Pull)
20
+
},
21
+
),
22
+
)
23
+
| End =>
24
+
if (! ended^) {
25
+
ended := true;
26
+
sink(. signal);
27
+
f(.);
28
+
}
29
+
| _ => sink(. signal)
14
30
}
15
-
| Close => ()
16
-
| Pull => talkback(.Pull)
17
-
}
18
-
}));
19
-
}
20
-
| End => {
21
-
if (!ended^) {
22
-
ended := true;
23
-
sink(.signal);
24
-
f(.);
25
-
}
26
-
}
27
-
| _ => sink(.signal)
28
-
};
29
-
});
30
-
}));
31
+
);
32
+
})
33
+
);
+12
-9
src/operators/wonka_operator_onPush.re
+12
-9
src/operators/wonka_operator_onPush.re
···
1
1
open Wonka_types;
2
2
3
-
let onPush = f => curry(source => curry(sink => {
4
-
source((.signal) => {
5
-
switch (signal) {
6
-
| Push(x) => f(.x)
7
-
| _ => ()
8
-
};
3
+
let onPush = f =>
4
+
curry(source =>
5
+
curry(sink =>
6
+
source((. signal) => {
7
+
switch (signal) {
8
+
| Push(x) => f(. x)
9
+
| _ => ()
10
+
};
9
11
10
-
sink(.signal);
11
-
});
12
-
}));
12
+
sink(. signal);
13
+
})
14
+
)
15
+
);
13
16
14
17
let tap = onPush;
+13
-11
src/operators/wonka_operator_onStart.re
+13
-11
src/operators/wonka_operator_onStart.re
···
1
1
open Wonka_types;
2
2
3
-
let onStart = f => curry(source => curry(sink => {
4
-
source((.signal) => {
5
-
switch (signal) {
6
-
| Start(_) => {
7
-
sink(.signal);
8
-
f(.);
9
-
}
10
-
| _ => sink(.signal)
11
-
};
12
-
});
13
-
}));
3
+
let onStart = f =>
4
+
curry(source =>
5
+
curry(sink =>
6
+
source((. signal) =>
7
+
switch (signal) {
8
+
| Start(_) =>
9
+
sink(. signal);
10
+
f(.);
11
+
| _ => sink(. signal)
12
+
}
13
+
)
14
+
)
15
+
);
+17
-13
src/operators/wonka_operator_scan.re
+17
-13
src/operators/wonka_operator_scan.re
···
1
1
open Wonka_types;
2
2
3
-
let scan = (f, seed) => curry(source => curry(sink => {
4
-
let acc = ref(seed);
3
+
let scan = (f, seed) =>
4
+
curry(source =>
5
+
curry(sink => {
6
+
let acc = ref(seed);
5
7
6
-
source((.signal) => sink(.
7
-
switch (signal) {
8
-
| Push(x) => {
9
-
acc := f(.acc^, x);
10
-
Push(acc^)
11
-
}
12
-
| Start(x) => Start(x)
13
-
| End => End
14
-
}
15
-
));
16
-
}));
8
+
source((. signal) =>
9
+
sink(.
10
+
switch (signal) {
11
+
| Push(x) =>
12
+
acc := f(. acc^, x);
13
+
Push(acc^);
14
+
| Start(x) => Start(x)
15
+
| End => End
16
+
},
17
+
)
18
+
);
19
+
})
20
+
);
+14
-12
src/operators/wonka_operator_skip.re
+14
-12
src/operators/wonka_operator_skip.re
···
1
1
open Wonka_types;
2
2
open Wonka_helpers;
3
3
4
-
let skip = wait => curry(source => curry(sink => {
5
-
let rest = ref(wait);
4
+
let skip = wait =>
5
+
curry(source =>
6
+
curry(sink => {
7
+
let rest = ref(wait);
6
8
7
-
captureTalkback(source, (.signal, talkback) => {
8
-
switch (signal) {
9
-
| Push(_) when rest^ > 0 => {
10
-
rest := rest^ - 1;
11
-
talkback(.Pull);
12
-
}
13
-
| _ => sink(.signal)
14
-
}
15
-
});
16
-
}));
9
+
captureTalkback(source, (. signal, talkback) =>
10
+
switch (signal) {
11
+
| Push(_) when rest^ > 0 =>
12
+
rest := rest^ - 1;
13
+
talkback(. Pull);
14
+
| _ => sink(. signal)
15
+
}
16
+
);
17
+
})
18
+
);
+60
-56
src/operators/wonka_operator_skipUntil.re
+60
-56
src/operators/wonka_operator_skipUntil.re
···
5
5
mutable skip: bool,
6
6
mutable ended: bool,
7
7
mutable gotSignal: bool,
8
-
mutable sourceTalkback: (.talkbackT) => unit,
9
-
mutable notifierTalkback: (.talkbackT) => unit
8
+
mutable sourceTalkback: (. talkbackT) => unit,
9
+
mutable notifierTalkback: (. talkbackT) => unit,
10
10
};
11
11
12
-
let skipUntil = notifier => curry(source => curry(sink => {
13
-
let state: skipUntilStateT = {
14
-
skip: true,
15
-
ended: false,
16
-
gotSignal: false,
17
-
sourceTalkback: talkbackPlaceholder,
18
-
notifierTalkback: talkbackPlaceholder
19
-
};
12
+
let skipUntil = notifier =>
13
+
curry(source =>
14
+
curry(sink => {
15
+
let state: skipUntilStateT = {
16
+
skip: true,
17
+
ended: false,
18
+
gotSignal: false,
19
+
sourceTalkback: talkbackPlaceholder,
20
+
notifierTalkback: talkbackPlaceholder,
21
+
};
20
22
21
-
source((.signal) => {
22
-
switch (signal) {
23
-
| Start(tb) => {
24
-
state.sourceTalkback = tb;
25
-
26
-
notifier((.signal) => {
23
+
source((. signal) =>
27
24
switch (signal) {
28
-
| Start(innerTb) => {
29
-
state.notifierTalkback = innerTb;
30
-
innerTb(.Pull);
31
-
tb(.Pull);
32
-
}
33
-
| Push(_) => {
34
-
state.skip = false;
35
-
state.notifierTalkback(.Close);
36
-
}
37
-
| End => ()
25
+
| Start(tb) =>
26
+
state.sourceTalkback = tb;
27
+
28
+
notifier((. signal) =>
29
+
switch (signal) {
30
+
| Start(innerTb) =>
31
+
state.notifierTalkback = innerTb;
32
+
innerTb(. Pull);
33
+
tb(. Pull);
34
+
| Push(_) =>
35
+
state.skip = false;
36
+
state.notifierTalkback(. Close);
37
+
| End => ()
38
+
}
39
+
);
40
+
| Push(_) when state.skip && !state.ended =>
41
+
state.sourceTalkback(. Pull)
42
+
| Push(_) when !state.ended =>
43
+
state.gotSignal = false;
44
+
sink(. signal);
45
+
| Push(_) => ()
46
+
| End =>
47
+
if (state.skip) {
48
+
state.notifierTalkback(. Close);
49
+
};
50
+
state.ended = true;
51
+
sink(. End);
38
52
}
39
-
});
40
-
}
41
-
| Push(_) when state.skip && !state.ended => state.sourceTalkback(.Pull)
42
-
| Push(_) when !state.ended => {
43
-
state.gotSignal = false;
44
-
sink(.signal)
45
-
}
46
-
| Push(_) => ()
47
-
| End => {
48
-
if (state.skip) state.notifierTalkback(.Close);
49
-
state.ended = true;
50
-
sink(.End)
51
-
}
52
-
}
53
-
});
53
+
);
54
54
55
-
sink(.Start((.signal) => {
56
-
switch (signal) {
57
-
| Close => {
58
-
if (state.skip) state.notifierTalkback(.Close);
59
-
state.ended = true;
60
-
state.sourceTalkback(.Close);
61
-
}
62
-
| Pull when !state.gotSignal && !state.ended => {
63
-
state.gotSignal = true;
64
-
state.sourceTalkback(.Pull);
65
-
}
66
-
| Pull => ()
67
-
}
68
-
}));
69
-
}));
55
+
sink(.
56
+
Start(
57
+
(. signal) =>
58
+
switch (signal) {
59
+
| Close =>
60
+
if (state.skip) {
61
+
state.notifierTalkback(. Close);
62
+
};
63
+
state.ended = true;
64
+
state.sourceTalkback(. Close);
65
+
| Pull when !state.gotSignal && !state.ended =>
66
+
state.gotSignal = true;
67
+
state.sourceTalkback(. Pull);
68
+
| Pull => ()
69
+
},
70
+
),
71
+
);
72
+
})
73
+
);
+18
-16
src/operators/wonka_operator_skipWhile.re
+18
-16
src/operators/wonka_operator_skipWhile.re
···
1
1
open Wonka_types;
2
2
open Wonka_helpers;
3
3
4
-
let skipWhile = f => curry(source => curry(sink => {
5
-
let skip = ref(true);
4
+
let skipWhile = f =>
5
+
curry(source =>
6
+
curry(sink => {
7
+
let skip = ref(true);
6
8
7
-
captureTalkback(source, (.signal, talkback) => {
8
-
switch (signal) {
9
-
| Push(x) when skip^ => {
10
-
if (f(.x)) {
11
-
talkback(.Pull);
12
-
} else {
13
-
skip := false;
14
-
sink(.signal);
15
-
};
16
-
}
17
-
| _ => sink(.signal)
18
-
}
19
-
});
20
-
}));
9
+
captureTalkback(source, (. signal, talkback) =>
10
+
switch (signal) {
11
+
| Push(x) when skip^ =>
12
+
if (f(. x)) {
13
+
talkback(. Pull);
14
+
} else {
15
+
skip := false;
16
+
sink(. signal);
17
+
}
18
+
| _ => sink(. signal)
19
+
}
20
+
);
21
+
})
22
+
);
+72
-69
src/operators/wonka_operator_switchMap.re
+72
-69
src/operators/wonka_operator_switchMap.re
···
2
2
open Wonka_helpers;
3
3
4
4
type switchMapStateT('a) = {
5
-
mutable outerTalkback: (.talkbackT) => unit,
6
-
mutable innerTalkback: (.talkbackT) => unit,
5
+
mutable outerTalkback: (. talkbackT) => unit,
6
+
mutable innerTalkback: (. talkbackT) => unit,
7
7
mutable innerActive: bool,
8
8
mutable closed: bool,
9
-
mutable ended: bool
9
+
mutable ended: bool,
10
10
};
11
11
12
-
let switchMap = f => curry(source => curry(sink => {
13
-
let state: switchMapStateT('a) = {
14
-
outerTalkback: talkbackPlaceholder,
15
-
innerTalkback: talkbackPlaceholder,
16
-
innerActive: false,
17
-
closed: false,
18
-
ended: false
19
-
};
12
+
let switchMap = f =>
13
+
curry(source =>
14
+
curry(sink => {
15
+
let state: switchMapStateT('a) = {
16
+
outerTalkback: talkbackPlaceholder,
17
+
innerTalkback: talkbackPlaceholder,
18
+
innerActive: false,
19
+
closed: false,
20
+
ended: false,
21
+
};
20
22
21
-
let applyInnerSource = innerSource =>
22
-
innerSource((.signal) => {
23
-
switch (signal) {
24
-
| End => {
25
-
state.innerActive = false;
26
-
state.innerTalkback = talkbackPlaceholder;
27
-
if (state.ended) sink(.End);
28
-
}
29
-
| Start(tb) => {
30
-
state.innerActive = true;
31
-
state.innerTalkback = tb;
32
-
tb(.Pull);
33
-
}
34
-
| Push(x) when !state.closed => {
35
-
sink(.Push(x));
36
-
state.innerTalkback(.Pull);
37
-
}
38
-
| Push(_) => ()
39
-
}
40
-
});
23
+
let applyInnerSource = innerSource =>
24
+
innerSource((. signal) =>
25
+
switch (signal) {
26
+
| End =>
27
+
state.innerActive = false;
28
+
state.innerTalkback = talkbackPlaceholder;
29
+
if (state.ended) {
30
+
sink(. End);
31
+
};
32
+
| Start(tb) =>
33
+
state.innerActive = true;
34
+
state.innerTalkback = tb;
35
+
tb(. Pull);
36
+
| Push(x) when !state.closed =>
37
+
sink(. Push(x));
38
+
state.innerTalkback(. Pull);
39
+
| Push(_) => ()
40
+
}
41
+
);
41
42
42
-
source((.signal) => {
43
-
switch (signal) {
44
-
| End when !state.ended => {
45
-
state.ended = true;
46
-
if (!state.innerActive) sink(.End);
47
-
}
48
-
| End => ()
49
-
| Start(tb) => {
50
-
state.outerTalkback = tb;
51
-
tb(.Pull);
52
-
}
53
-
| Push(x) when !state.ended => {
54
-
if (state.innerActive) {
55
-
state.innerTalkback(.Close);
56
-
state.innerTalkback = talkbackPlaceholder;
57
-
}
58
-
applyInnerSource(f(.x));
59
-
state.outerTalkback(.Pull);
60
-
}
61
-
| Push(_) => ()
62
-
}
63
-
});
43
+
source((. signal) =>
44
+
switch (signal) {
45
+
| End when !state.ended =>
46
+
state.ended = true;
47
+
if (!state.innerActive) {
48
+
sink(. End);
49
+
};
50
+
| End => ()
51
+
| Start(tb) =>
52
+
state.outerTalkback = tb;
53
+
tb(. Pull);
54
+
| Push(x) when !state.ended =>
55
+
if (state.innerActive) {
56
+
state.innerTalkback(. Close);
57
+
state.innerTalkback = talkbackPlaceholder;
58
+
};
59
+
applyInnerSource(f(. x));
60
+
state.outerTalkback(. Pull);
61
+
| Push(_) => ()
62
+
}
63
+
);
64
64
65
-
sink(.Start((.signal) => {
66
-
switch (signal) {
67
-
| Pull => state.innerTalkback(.Pull)
68
-
| Close => {
69
-
state.innerTalkback(.Close);
70
-
if (!state.ended) {
71
-
state.ended = true;
72
-
state.closed = true;
73
-
state.outerTalkback(.Close);
74
-
state.innerTalkback = talkbackPlaceholder;
75
-
}
76
-
}
77
-
}
78
-
}));
79
-
}));
65
+
sink(.
66
+
Start(
67
+
(. signal) =>
68
+
switch (signal) {
69
+
| Pull => state.innerTalkback(. Pull)
70
+
| Close =>
71
+
state.innerTalkback(. Close);
72
+
if (!state.ended) {
73
+
state.ended = true;
74
+
state.closed = true;
75
+
state.outerTalkback(. Close);
76
+
state.innerTalkback = talkbackPlaceholder;
77
+
};
78
+
},
79
+
),
80
+
);
81
+
})
82
+
);
80
83
81
-
let switchAll = source => switchMap((.x) => x, source);
84
+
let switchAll = source => switchMap((. x) => x, source);
+37
-37
src/operators/wonka_operator_take.re
+37
-37
src/operators/wonka_operator_take.re
···
3
3
4
4
type takeStateT = {
5
5
mutable taken: int,
6
-
mutable talkback: (.talkbackT) => unit
6
+
mutable talkback: (. talkbackT) => unit,
7
7
};
8
8
9
-
let take = max => curry(source => curry(sink => {
10
-
let state: takeStateT = {
11
-
taken: 0,
12
-
talkback: talkbackPlaceholder
13
-
};
9
+
let take = max =>
10
+
curry(source =>
11
+
curry(sink => {
12
+
let state: takeStateT = {taken: 0, talkback: talkbackPlaceholder};
14
13
15
-
source((.signal) => {
16
-
switch (signal) {
17
-
| Start(tb) => state.talkback = tb;
18
-
| Push(_) when state.taken < max => {
19
-
state.taken = state.taken + 1;
20
-
sink(.signal);
14
+
source((. signal) =>
15
+
switch (signal) {
16
+
| Start(tb) => state.talkback = tb
17
+
| Push(_) when state.taken < max =>
18
+
state.taken = state.taken + 1;
19
+
sink(. signal);
21
20
22
-
if (state.taken === max) {
23
-
sink(.End);
24
-
state.talkback(.Close);
25
-
};
26
-
}
27
-
| Push(_) => ()
28
-
| End when state.taken < max => {
29
-
state.taken = max;
30
-
sink(.End)
31
-
}
32
-
| End => ()
33
-
}
34
-
});
21
+
if (state.taken === max) {
22
+
sink(. End);
23
+
state.talkback(. Close);
24
+
};
25
+
| Push(_) => ()
26
+
| End when state.taken < max =>
27
+
state.taken = max;
28
+
sink(. End);
29
+
| End => ()
30
+
}
31
+
);
35
32
36
-
sink(.Start((.signal) => {
37
-
if (state.taken < max) {
38
-
switch (signal) {
39
-
| Pull => state.talkback(.Pull);
40
-
| Close => {
41
-
state.taken = max;
42
-
state.talkback(.Close);
43
-
}
44
-
}
45
-
};
46
-
}));
47
-
}));
33
+
sink(.
34
+
Start(
35
+
(. signal) =>
36
+
if (state.taken < max) {
37
+
switch (signal) {
38
+
| Pull => state.talkback(. Pull)
39
+
| Close =>
40
+
state.taken = max;
41
+
state.talkback(. Close);
42
+
};
43
+
},
44
+
),
45
+
);
46
+
})
47
+
);
+20
-18
src/operators/wonka_operator_takeLast.re
+20
-18
src/operators/wonka_operator_takeLast.re
···
1
1
open Wonka_types;
2
2
open Wonka_helpers;
3
3
4
-
let takeLast = max => curry(source => curry(sink => {
5
-
open Rebel;
6
-
let queue = MutableQueue.make();
4
+
let takeLast = max =>
5
+
curry(source =>
6
+
curry(sink => {
7
+
open Rebel;
8
+
let queue = MutableQueue.make();
7
9
8
-
captureTalkback(source, (.signal, talkback) => {
9
-
switch (signal) {
10
-
| Start(_) => talkback(.Pull)
11
-
| Push(x) => {
12
-
let size = MutableQueue.size(queue);
13
-
if (size >= max && max > 0) {
14
-
ignore(MutableQueue.pop(queue));
15
-
};
10
+
captureTalkback(source, (. signal, talkback) =>
11
+
switch (signal) {
12
+
| Start(_) => talkback(. Pull)
13
+
| Push(x) =>
14
+
let size = MutableQueue.size(queue);
15
+
if (size >= max && max > 0) {
16
+
ignore(MutableQueue.pop(queue));
17
+
};
16
18
17
-
MutableQueue.add(queue, x);
18
-
talkback(.Pull);
19
-
}
20
-
| End => makeTrampoline(sink, (.) => MutableQueue.pop(queue))
21
-
}
22
-
});
23
-
}));
19
+
MutableQueue.add(queue, x);
20
+
talkback(. Pull);
21
+
| End => makeTrampoline(sink, (.) => MutableQueue.pop(queue))
22
+
}
23
+
);
24
+
})
25
+
);
+48
-47
src/operators/wonka_operator_takeUntil.re
+48
-47
src/operators/wonka_operator_takeUntil.re
···
3
3
4
4
type takeUntilStateT = {
5
5
mutable ended: bool,
6
-
mutable sourceTalkback: (.talkbackT) => unit,
7
-
mutable notifierTalkback: (.talkbackT) => unit
6
+
mutable sourceTalkback: (. talkbackT) => unit,
7
+
mutable notifierTalkback: (. talkbackT) => unit,
8
8
};
9
9
10
-
let takeUntil = notifier => curry(source => curry(sink => {
11
-
let state: takeUntilStateT = {
12
-
ended: false,
13
-
sourceTalkback: talkbackPlaceholder,
14
-
notifierTalkback: talkbackPlaceholder
15
-
};
16
-
17
-
source((.signal) => {
18
-
switch (signal) {
19
-
| Start(tb) => {
20
-
state.sourceTalkback = tb;
10
+
let takeUntil = notifier =>
11
+
curry(source =>
12
+
curry(sink => {
13
+
let state: takeUntilStateT = {
14
+
ended: false,
15
+
sourceTalkback: talkbackPlaceholder,
16
+
notifierTalkback: talkbackPlaceholder,
17
+
};
21
18
22
-
notifier((.signal) => {
19
+
source((. signal) =>
23
20
switch (signal) {
24
-
| Start(innerTb) => {
25
-
state.notifierTalkback = innerTb;
26
-
innerTb(.Pull);
27
-
}
28
-
| Push(_) => {
21
+
| Start(tb) =>
22
+
state.sourceTalkback = tb;
23
+
24
+
notifier((. signal) =>
25
+
switch (signal) {
26
+
| Start(innerTb) =>
27
+
state.notifierTalkback = innerTb;
28
+
innerTb(. Pull);
29
+
| Push(_) =>
30
+
state.ended = true;
31
+
state.notifierTalkback(. Close);
32
+
state.sourceTalkback(. Close);
33
+
sink(. End);
34
+
| End => ()
35
+
}
36
+
);
37
+
| End when !state.ended =>
38
+
state.notifierTalkback(. Close);
29
39
state.ended = true;
30
-
state.notifierTalkback(.Close);
31
-
state.sourceTalkback(.Close);
32
-
sink(.End);
33
-
}
40
+
sink(. End);
34
41
| End => ()
42
+
| Push(_) when !state.ended => sink(. signal)
43
+
| Push(_) => ()
35
44
}
36
-
});
37
-
}
38
-
| End when !state.ended => {
39
-
state.notifierTalkback(.Close);
40
-
state.ended = true;
41
-
sink(.End);
42
-
}
43
-
| End => ()
44
-
| Push(_) when !state.ended => sink(.signal)
45
-
| Push(_) => ()
46
-
}
47
-
});
45
+
);
48
46
49
-
sink(.Start((.signal) => {
50
-
if (!state.ended) {
51
-
switch (signal) {
52
-
| Close => {
53
-
state.sourceTalkback(.Close);
54
-
state.notifierTalkback(.Close);
55
-
}
56
-
| Pull => state.sourceTalkback(.Pull)
57
-
}
58
-
};
59
-
}));
60
-
}));
47
+
sink(.
48
+
Start(
49
+
(. signal) =>
50
+
if (!state.ended) {
51
+
switch (signal) {
52
+
| Close =>
53
+
state.sourceTalkback(. Close);
54
+
state.notifierTalkback(. Close);
55
+
| Pull => state.sourceTalkback(. Pull)
56
+
};
57
+
},
58
+
),
59
+
);
60
+
})
61
+
);
+40
-38
src/operators/wonka_operator_takeWhile.re
+40
-38
src/operators/wonka_operator_takeWhile.re
···
1
1
open Wonka_types;
2
2
open Wonka_helpers;
3
3
4
-
let takeWhile = f => curry(source => curry(sink => {
5
-
let ended = ref(false);
6
-
let talkback = ref(talkbackPlaceholder);
4
+
let takeWhile = f =>
5
+
curry(source =>
6
+
curry(sink => {
7
+
let ended = ref(false);
8
+
let talkback = ref(talkbackPlaceholder);
7
9
8
-
source((.signal) => {
9
-
switch (signal) {
10
-
| Start(tb) => {
11
-
talkback := tb;
12
-
sink(.signal);
13
-
}
14
-
| End when !ended^ => {
15
-
ended := true;
16
-
sink(.End);
17
-
}
18
-
| End => ()
19
-
| Push(x) when !ended^ => {
20
-
if (!f(.x)) {
21
-
ended := true;
22
-
sink(.End);
23
-
talkback^(.Close);
24
-
} else {
25
-
sink(.signal);
26
-
};
27
-
}
28
-
| Push(_) => ()
29
-
}
30
-
});
10
+
source((. signal) =>
11
+
switch (signal) {
12
+
| Start(tb) =>
13
+
talkback := tb;
14
+
sink(. signal);
15
+
| End when ! ended^ =>
16
+
ended := true;
17
+
sink(. End);
18
+
| End => ()
19
+
| Push(x) when ! ended^ =>
20
+
if (!f(. x)) {
21
+
ended := true;
22
+
sink(. End);
23
+
talkback^(. Close);
24
+
} else {
25
+
sink(. signal);
26
+
}
27
+
| Push(_) => ()
28
+
}
29
+
);
31
30
32
-
sink(.Start((.signal) => {
33
-
if (!ended^) {
34
-
switch (signal) {
35
-
| Pull => talkback^(.Pull);
36
-
| Close => {
37
-
ended := true;
38
-
talkback^(.Close);
39
-
}
40
-
}
41
-
};
42
-
}));
43
-
}));
31
+
sink(.
32
+
Start(
33
+
(. signal) =>
34
+
if (! ended^) {
35
+
switch (signal) {
36
+
| Pull => talkback^(. Pull)
37
+
| Close =>
38
+
ended := true;
39
+
talkback^(. Close);
40
+
};
41
+
},
42
+
),
43
+
);
44
+
})
45
+
);
+15
-16
src/sinks/wonka_sink_publish.re
+15
-16
src/sinks/wonka_sink_publish.re
···
2
2
open Wonka_helpers;
3
3
4
4
type publishStateT = {
5
-
mutable talkback: (.talkbackT) => unit,
6
-
mutable ended: bool
5
+
mutable talkback: (. talkbackT) => unit,
6
+
mutable ended: bool,
7
7
};
8
8
9
9
let publish = source => {
10
-
let state: publishStateT = {
11
-
talkback: talkbackPlaceholder,
12
-
ended: false
13
-
};
10
+
let state: publishStateT = {talkback: talkbackPlaceholder, ended: false};
14
11
15
-
source((.signal) => {
12
+
source((. signal) =>
16
13
switch (signal) {
17
-
| Start(x) => {
14
+
| Start(x) =>
18
15
state.talkback = x;
19
-
x(.Pull);
20
-
}
21
-
| Push(_) => if (!state.ended) state.talkback(.Pull);
22
-
| End => state.ended = true;
16
+
x(. Pull);
17
+
| Push(_) =>
18
+
if (!state.ended) {
19
+
state.talkback(. Pull);
20
+
}
21
+
| End => state.ended = true
23
22
}
24
-
});
23
+
);
25
24
26
25
{
27
26
unsubscribe: () =>
28
27
if (!state.ended) {
29
28
state.ended = true;
30
-
state.talkback(.Close);
31
-
}
32
-
}
29
+
state.talkback(. Close);
30
+
},
31
+
};
33
32
};
+29
-32
src/sinks/wonka_sink_subscribe.re
+29
-32
src/sinks/wonka_sink_subscribe.re
···
2
2
open Wonka_helpers;
3
3
4
4
type subscribeStateT = {
5
-
mutable talkback: (.talkbackT) => unit,
6
-
mutable ended: bool
5
+
mutable talkback: (. talkbackT) => unit,
6
+
mutable ended: bool,
7
7
};
8
8
9
-
let subscribe = f => curry(source => {
10
-
let state: subscribeStateT = {
11
-
talkback: talkbackPlaceholder,
12
-
ended: false
13
-
};
9
+
let subscribe = f =>
10
+
curry(source => {
11
+
let state: subscribeStateT = {
12
+
talkback: talkbackPlaceholder,
13
+
ended: false,
14
+
};
15
+
16
+
source((. signal) =>
17
+
switch (signal) {
18
+
| Start(x) =>
19
+
state.talkback = x;
20
+
x(. Pull);
21
+
| Push(x) when !state.ended =>
22
+
f(. x);
23
+
state.talkback(. Pull);
24
+
| Push(_) => ()
25
+
| End => state.ended = true
26
+
}
27
+
);
14
28
15
-
source((.signal) => {
16
-
switch (signal) {
17
-
| Start(x) => {
18
-
state.talkback = x;
19
-
x(.Pull);
20
-
}
21
-
| Push(x) when !state.ended => {
22
-
f(.x);
23
-
state.talkback(.Pull);
24
-
}
25
-
| Push(_) => ()
26
-
| End => state.ended = true;
27
-
}
29
+
{
30
+
unsubscribe: () =>
31
+
if (!state.ended) {
32
+
state.ended = true;
33
+
state.talkback(. Close);
34
+
},
35
+
};
28
36
});
29
37
30
-
{
31
-
unsubscribe: () =>
32
-
if (!state.ended) {
33
-
state.ended = true;
34
-
state.talkback(.Close);
35
-
}
36
-
}
37
-
});
38
-
39
-
let forEach = f => curry(source => {
40
-
ignore(subscribe(f, source));
41
-
});
38
+
let forEach = f => curry(source => ignore(subscribe(f, source)));
+31
-33
src/sources/wonka_source_fromArray.re
+31
-33
src/sources/wonka_source_fromArray.re
···
4
4
mutable index: int,
5
5
mutable ended: bool,
6
6
mutable looping: bool,
7
-
mutable pull: bool
7
+
mutable pull: bool,
8
8
};
9
9
10
-
let fromArray = arr => curry(sink => {
11
-
let size = Rebel.Array.size(arr);
12
-
let state = {
13
-
index: 0,
14
-
ended: false,
15
-
looping: false,
16
-
pull: false
17
-
};
10
+
let fromArray = arr =>
11
+
curry(sink => {
12
+
let size = Rebel.Array.size(arr);
13
+
let state = {index: 0, ended: false, looping: false, pull: false};
18
14
19
-
sink(.Start((.signal) => {
20
-
switch (signal, state.looping) {
21
-
| (Pull, false) => {
22
-
state.pull = true;
23
-
state.looping = true;
15
+
sink(.
16
+
Start(
17
+
(. signal) =>
18
+
switch (signal, state.looping) {
19
+
| (Pull, false) =>
20
+
state.pull = true;
21
+
state.looping = true;
24
22
25
-
while (state.pull && !state.ended) {
26
-
let index = state.index;
27
-
if (index < size) {
28
-
let x = Rebel.Array.getUnsafe(arr, index);
29
-
state.index = index + 1;
30
-
state.pull = false;
31
-
sink(.Push(x));
32
-
} else {
33
-
state.ended = true;
34
-
sink(.End);
35
-
}
36
-
};
23
+
while (state.pull && !state.ended) {
24
+
let index = state.index;
25
+
if (index < size) {
26
+
let x = Rebel.Array.getUnsafe(arr, index);
27
+
state.index = index + 1;
28
+
state.pull = false;
29
+
sink(. Push(x));
30
+
} else {
31
+
state.ended = true;
32
+
sink(. End);
33
+
};
34
+
};
37
35
38
-
state.looping = false;
39
-
}
40
-
| (Pull, true) => state.pull = true
41
-
| (Close, _) => state.ended = true
42
-
}
43
-
}));
44
-
});
36
+
state.looping = false;
37
+
| (Pull, true) => state.pull = true
38
+
| (Close, _) => state.ended = true
39
+
},
40
+
),
41
+
);
42
+
});
+29
-33
src/sources/wonka_source_fromList.re
+29
-33
src/sources/wonka_source_fromList.re
···
4
4
mutable value: 'a,
5
5
mutable ended: bool,
6
6
mutable looping: bool,
7
-
mutable pull: bool
7
+
mutable pull: bool,
8
8
};
9
9
10
-
let fromList = ls => curry(sink => {
11
-
let state = {
12
-
value: ls,
13
-
ended: false,
14
-
looping: false,
15
-
pull: false
16
-
};
10
+
let fromList = ls =>
11
+
curry(sink => {
12
+
let state = {value: ls, ended: false, looping: false, pull: false};
17
13
18
-
sink(.Start((.signal) => {
19
-
switch (signal, state.looping) {
20
-
| (Pull, false) => {
21
-
state.pull = true;
22
-
state.looping = true;
14
+
sink(.
15
+
Start(
16
+
(. signal) =>
17
+
switch (signal, state.looping) {
18
+
| (Pull, false) =>
19
+
state.pull = true;
20
+
state.looping = true;
23
21
24
-
while (state.pull && !state.ended) {
25
-
switch (state.value) {
26
-
| [x, ...rest] => {
27
-
state.value = rest;
28
-
state.pull = false;
29
-
sink(.Push(x));
30
-
}
31
-
| [] => {
32
-
state.ended = true;
33
-
sink(.End);
34
-
}
35
-
}
36
-
};
22
+
while (state.pull && !state.ended) {
23
+
switch (state.value) {
24
+
| [x, ...rest] =>
25
+
state.value = rest;
26
+
state.pull = false;
27
+
sink(. Push(x));
28
+
| [] =>
29
+
state.ended = true;
30
+
sink(. End);
31
+
};
32
+
};
37
33
38
-
state.looping = false;
39
-
}
40
-
| (Pull, true) => state.pull = true
41
-
| (Close, _) => state.ended = true
42
-
}
43
-
}));
44
-
});
34
+
state.looping = false;
35
+
| (Pull, true) => state.pull = true
36
+
| (Close, _) => state.ended = true
37
+
},
38
+
),
39
+
);
40
+
});
+16
-13
src/sources/wonka_source_fromValue.re
+16
-13
src/sources/wonka_source_fromValue.re
···
1
1
open Wonka_types;
2
2
3
-
let fromValue = x => curry(sink => {
4
-
let ended = ref(false);
3
+
let fromValue = x =>
4
+
curry(sink => {
5
+
let ended = ref(false);
5
6
6
-
sink(.Start((.signal) => {
7
-
switch (signal) {
8
-
| Pull when !ended^ => {
9
-
ended := true;
10
-
sink(.Push(x));
11
-
sink(.End);
12
-
}
13
-
| _ => ()
14
-
}
15
-
}));
16
-
});
7
+
sink(.
8
+
Start(
9
+
(. signal) =>
10
+
switch (signal) {
11
+
| Pull when ! ended^ =>
12
+
ended := true;
13
+
sink(. Push(x));
14
+
sink(. End);
15
+
| _ => ()
16
+
},
17
+
),
18
+
);
19
+
});
+17
-12
src/sources/wonka_source_make.re
+17
-12
src/sources/wonka_source_make.re
···
1
1
open Wonka_types;
2
2
3
-
let make = f => curry(sink => {
4
-
let teardown = ref((.) => ());
3
+
let make = f =>
4
+
curry(sink => {
5
+
let teardown = ref((.) => ());
5
6
6
-
sink(.Start((.signal) => {
7
-
switch (signal) {
8
-
| Close => teardown^(.)
9
-
| Pull => ()
10
-
}
11
-
}));
7
+
sink(.
8
+
Start(
9
+
(. signal) =>
10
+
switch (signal) {
11
+
| Close => teardown^(.)
12
+
| Pull => ()
13
+
},
14
+
),
15
+
);
12
16
13
-
teardown := f(.{
14
-
next: value => sink(.Push(value)),
15
-
complete: () => sink(.End)
17
+
teardown :=
18
+
f(. {
19
+
next: value => sink(. Push(value)),
20
+
complete: () => sink(. End),
21
+
});
16
22
});
17
-
});
+12
-9
src/sources/wonka_source_makeSubject.re
+12
-9
src/sources/wonka_source_makeSubject.re
···
2
2
3
3
type subjectState('a) = {
4
4
mutable sinks: Rebel.Array.t(sinkT('a)),
5
-
mutable ended: bool
5
+
mutable ended: bool,
6
6
};
7
7
8
8
let makeSubject = () => {
···
13
13
14
14
let source = sink => {
15
15
state.sinks = Rebel.Array.append(state.sinks, sink);
16
-
sink(.Start((.signal) => {
17
-
if (signal === Close) {
18
-
state.sinks = Rebel.Array.filter(state.sinks, x => x !== sink);
19
-
}
20
-
}));
16
+
sink(.
17
+
Start(
18
+
(. signal) =>
19
+
if (signal === Close) {
20
+
state.sinks = Rebel.Array.filter(state.sinks, x => x !== sink);
21
+
},
22
+
),
23
+
);
21
24
};
22
25
23
26
let next = value =>
24
27
if (!state.ended) {
25
-
Rebel.Array.forEach(state.sinks, sink => sink(.Push(value)));
28
+
Rebel.Array.forEach(state.sinks, sink => sink(. Push(value)));
26
29
};
27
30
28
31
let complete = () =>
29
32
if (!state.ended) {
30
33
state.ended = true;
31
-
Rebel.Array.forEach(state.sinks, sink => sink(.End));
34
+
Rebel.Array.forEach(state.sinks, sink => sink(. End));
32
35
};
33
36
34
-
{ source, next, complete }
37
+
{source, next, complete};
35
38
};
+3
-3
src/sources/wonka_source_primitives.re
+3
-3
src/sources/wonka_source_primitives.re
+49
-40
src/web/wonka_operator_debounce.re
+49
-40
src/web/wonka_operator_debounce.re
···
1
1
open Wonka_types;
2
2
3
-
let debounce = f => curry(source => curry(sink => {
4
-
let gotEndSignal = ref(false);
5
-
let id: ref(option(Js.Global.timeoutId)) = ref(None);
3
+
let debounce = f =>
4
+
curry(source =>
5
+
curry(sink => {
6
+
let gotEndSignal = ref(false);
7
+
let id: ref(option(Js.Global.timeoutId)) = ref(None);
6
8
7
-
let clearTimeout = () =>
8
-
switch (id^) {
9
-
| Some(timeoutId) => {
10
-
id := None;
11
-
Js.Global.clearTimeout(timeoutId);
12
-
}
13
-
| None => ()
14
-
};
9
+
let clearTimeout = () =>
10
+
switch (id^) {
11
+
| Some(timeoutId) =>
12
+
id := None;
13
+
Js.Global.clearTimeout(timeoutId);
14
+
| None => ()
15
+
};
15
16
16
-
source((.signal) => {
17
-
switch (signal) {
18
-
| Start(tb) => {
19
-
sink(.Start((.signal) => {
17
+
source((. signal) =>
20
18
switch (signal) {
21
-
| Close => {
19
+
| Start(tb) =>
20
+
sink(.
21
+
Start(
22
+
(. signal) =>
23
+
switch (signal) {
24
+
| Close =>
25
+
clearTimeout();
26
+
tb(. Close);
27
+
| _ => tb(. signal)
28
+
},
29
+
),
30
+
)
31
+
| Push(x) =>
22
32
clearTimeout();
23
-
tb(.Close);
24
-
}
25
-
| _ => tb(.signal)
26
-
}
27
-
}));
28
-
}
29
-
| Push(x) => {
30
-
clearTimeout();
31
-
id := Some(Js.Global.setTimeout(() => {
32
-
id := None;
33
-
sink(.signal);
34
-
if (gotEndSignal^) sink(.End);
35
-
}, f(.x)));
36
-
}
37
-
| End => {
38
-
gotEndSignal := true;
33
+
id :=
34
+
Some(
35
+
Js.Global.setTimeout(
36
+
() => {
37
+
id := None;
38
+
sink(. signal);
39
+
if (gotEndSignal^) {
40
+
sink(. End);
41
+
};
42
+
},
43
+
f(. x),
44
+
),
45
+
);
46
+
| End =>
47
+
gotEndSignal := true;
39
48
40
-
switch (id^) {
41
-
| None => sink(.End)
42
-
| _ => ()
43
-
};
44
-
}
45
-
}
46
-
});
47
-
}));
49
+
switch (id^) {
50
+
| None => sink(. End)
51
+
| _ => ()
52
+
};
53
+
}
54
+
);
55
+
})
56
+
);
+47
-36
src/web/wonka_operator_delay.re
+47
-36
src/web/wonka_operator_delay.re
···
1
1
open Wonka_types;
2
2
3
3
type delayStateT = {
4
-
mutable talkback: (.talkbackT) => unit,
4
+
mutable talkback: (. talkbackT) => unit,
5
5
mutable active: int,
6
-
mutable gotEndSignal: bool
6
+
mutable gotEndSignal: bool,
7
7
};
8
8
9
-
let delay = wait => curry(source => curry(sink => {
10
-
let state: delayStateT = {
11
-
talkback: Wonka_helpers.talkbackPlaceholder,
12
-
active: 0,
13
-
gotEndSignal: false
14
-
};
9
+
let delay = wait =>
10
+
curry(source =>
11
+
curry(sink => {
12
+
let state: delayStateT = {
13
+
talkback: Wonka_helpers.talkbackPlaceholder,
14
+
active: 0,
15
+
gotEndSignal: false,
16
+
};
15
17
16
-
source((.signal) => {
17
-
switch (signal) {
18
-
| Start(tb) => state.talkback = tb
19
-
| _ when !state.gotEndSignal => {
20
-
state.active = state.active + 1;
21
-
ignore(Js.Global.setTimeout(() => {
22
-
if (state.gotEndSignal && state.active === 0) {
23
-
sink(.End);
24
-
} else {
25
-
state.active = state.active - 1;
26
-
};
18
+
source((. signal) =>
19
+
switch (signal) {
20
+
| Start(tb) => state.talkback = tb
21
+
| _ when !state.gotEndSignal =>
22
+
state.active = state.active + 1;
23
+
ignore(
24
+
Js.Global.setTimeout(
25
+
() => {
26
+
if (state.gotEndSignal && state.active === 0) {
27
+
sink(. End);
28
+
} else {
29
+
state.active = state.active - 1;
30
+
};
27
31
28
-
sink(.signal);
29
-
}, wait));
30
-
}
31
-
| _ => ()
32
-
}
33
-
});
32
+
sink(. signal);
33
+
},
34
+
wait,
35
+
),
36
+
);
37
+
| _ => ()
38
+
}
39
+
);
34
40
35
-
sink(.Start((.signal) => {
36
-
switch (signal) {
37
-
| Close => {
38
-
state.gotEndSignal = true;
39
-
if (state.active === 0) sink(.End);
40
-
}
41
-
| _ when !state.gotEndSignal => state.talkback(.signal)
42
-
| _ => ()
43
-
}
44
-
}));
45
-
}));
41
+
sink(.
42
+
Start(
43
+
(. signal) =>
44
+
switch (signal) {
45
+
| Close =>
46
+
state.gotEndSignal = true;
47
+
if (state.active === 0) {
48
+
sink(. End);
49
+
};
50
+
| _ when !state.gotEndSignal => state.talkback(. signal)
51
+
| _ => ()
52
+
},
53
+
),
54
+
);
55
+
})
56
+
);
+22
-14
src/web/wonka_operator_interval.re
+22
-14
src/web/wonka_operator_interval.re
···
1
1
open Wonka_types;
2
2
3
-
let interval = p => curry(sink => {
4
-
let i = ref(0);
5
-
let id = Js.Global.setInterval(() => {
6
-
let num = i^;
7
-
i := i^ + 1;
8
-
sink(.Push(num));
9
-
}, p);
3
+
let interval = p =>
4
+
curry(sink => {
5
+
let i = ref(0);
6
+
let id =
7
+
Js.Global.setInterval(
8
+
() => {
9
+
let num = i^;
10
+
i := i^ + 1;
11
+
sink(. Push(num));
12
+
},
13
+
p,
14
+
);
10
15
11
-
sink(.Start((.signal) => {
12
-
switch (signal) {
13
-
| Close => Js.Global.clearInterval(id)
14
-
| _ => ()
15
-
}
16
-
}));
17
-
});
16
+
sink(.
17
+
Start(
18
+
(. signal) =>
19
+
switch (signal) {
20
+
| Close => Js.Global.clearInterval(id)
21
+
| _ => ()
22
+
},
23
+
),
24
+
);
25
+
});
+50
-49
src/web/wonka_operator_sample.re
+50
-49
src/web/wonka_operator_sample.re
···
3
3
type sampleStateT('a) = {
4
4
mutable ended: bool,
5
5
mutable value: option('a),
6
-
mutable sourceTalkback: (.talkbackT) => unit,
7
-
mutable notifierTalkback: (.talkbackT) => unit
6
+
mutable sourceTalkback: (. talkbackT) => unit,
7
+
mutable notifierTalkback: (. talkbackT) => unit,
8
8
};
9
9
10
-
let sample = notifier => curry(source => curry(sink => {
11
-
let state = {
12
-
ended: false,
13
-
value: None,
14
-
sourceTalkback: (._: talkbackT) => (),
15
-
notifierTalkback: (._: talkbackT) => ()
16
-
};
10
+
let sample = notifier =>
11
+
curry(source =>
12
+
curry(sink => {
13
+
let state = {
14
+
ended: false,
15
+
value: None,
16
+
sourceTalkback: (. _: talkbackT) => (),
17
+
notifierTalkback: (. _: talkbackT) => (),
18
+
};
17
19
18
-
source((.signal) => {
19
-
switch (signal) {
20
-
| Start(tb) => state.sourceTalkback = tb
21
-
| End => {
22
-
state.ended = true;
23
-
state.notifierTalkback(.Close);
24
-
sink(.End);
25
-
}
26
-
| Push(x) => state.value = Some(x)
27
-
}
28
-
});
20
+
source((. signal) =>
21
+
switch (signal) {
22
+
| Start(tb) => state.sourceTalkback = tb
23
+
| End =>
24
+
state.ended = true;
25
+
state.notifierTalkback(. Close);
26
+
sink(. End);
27
+
| Push(x) => state.value = Some(x)
28
+
}
29
+
);
29
30
30
-
notifier((.signal) => {
31
-
switch (signal, state.value) {
32
-
| (Start(tb), _) => state.notifierTalkback = tb
33
-
| (End, _) => {
34
-
state.ended = true;
35
-
state.sourceTalkback(.Close);
36
-
sink(.End);
37
-
}
38
-
| (Push(_), Some(x)) when !state.ended => {
39
-
state.value = None;
40
-
sink(.Push(x));
41
-
}
42
-
| (Push(_), _) => ()
43
-
}
44
-
});
31
+
notifier((. signal) =>
32
+
switch (signal, state.value) {
33
+
| (Start(tb), _) => state.notifierTalkback = tb
34
+
| (End, _) =>
35
+
state.ended = true;
36
+
state.sourceTalkback(. Close);
37
+
sink(. End);
38
+
| (Push(_), Some(x)) when !state.ended =>
39
+
state.value = None;
40
+
sink(. Push(x));
41
+
| (Push(_), _) => ()
42
+
}
43
+
);
45
44
46
-
sink(.Start((.signal) => {
47
-
switch (signal) {
48
-
| Pull => {
49
-
state.sourceTalkback(.Pull);
50
-
state.notifierTalkback(.Pull);
51
-
}
52
-
| Close => {
53
-
state.ended = true;
54
-
state.sourceTalkback(.Close);
55
-
state.notifierTalkback(.Close);
56
-
}
57
-
}
58
-
}));
59
-
}));
45
+
sink(.
46
+
Start(
47
+
(. signal) =>
48
+
switch (signal) {
49
+
| Pull =>
50
+
state.sourceTalkback(. Pull);
51
+
state.notifierTalkback(. Pull);
52
+
| Close =>
53
+
state.ended = true;
54
+
state.sourceTalkback(. Close);
55
+
state.notifierTalkback(. Close);
56
+
},
57
+
),
58
+
);
59
+
})
60
+
);
+43
-35
src/web/wonka_operator_throttle.re
+43
-35
src/web/wonka_operator_throttle.re
···
1
1
open Wonka_types;
2
2
3
-
let throttle = f => curry(source => curry(sink => {
4
-
let skip = ref(false);
5
-
let id: ref(option(Js.Global.timeoutId)) = ref(None);
6
-
let clearTimeout = () =>
7
-
switch (id^) {
8
-
| Some(timeoutId) => Js.Global.clearTimeout(timeoutId);
9
-
| None => ()
10
-
};
3
+
let throttle = f =>
4
+
curry(source =>
5
+
curry(sink => {
6
+
let skip = ref(false);
7
+
let id: ref(option(Js.Global.timeoutId)) = ref(None);
8
+
let clearTimeout = () =>
9
+
switch (id^) {
10
+
| Some(timeoutId) => Js.Global.clearTimeout(timeoutId)
11
+
| None => ()
12
+
};
11
13
12
-
source((.signal) => {
13
-
switch (signal) {
14
-
| Start(tb) => {
15
-
sink(.Start((.signal) => {
14
+
source((. signal) =>
16
15
switch (signal) {
17
-
| Close => {
16
+
| Start(tb) =>
17
+
sink(.
18
+
Start(
19
+
(. signal) =>
20
+
switch (signal) {
21
+
| Close =>
22
+
clearTimeout();
23
+
tb(. Close);
24
+
| _ => tb(. signal)
25
+
},
26
+
),
27
+
)
28
+
| End =>
18
29
clearTimeout();
19
-
tb(.Close);
20
-
}
21
-
| _ => tb(.signal)
30
+
sink(. End);
31
+
| Push(x) when ! skip^ =>
32
+
skip := true;
33
+
clearTimeout();
34
+
id :=
35
+
Some(
36
+
Js.Global.setTimeout(
37
+
() => {
38
+
id := None;
39
+
skip := false;
40
+
},
41
+
f(. x),
42
+
),
43
+
);
44
+
sink(. signal);
45
+
| Push(_) => ()
22
46
}
23
-
}));
24
-
}
25
-
| End => {
26
-
clearTimeout();
27
-
sink(.End);
28
-
}
29
-
| Push(x) when !skip^ => {
30
-
skip := true;
31
-
clearTimeout();
32
-
id := Some(Js.Global.setTimeout(() => {
33
-
id := None;
34
-
skip := false;
35
-
}, f(.x)));
36
-
sink(.signal);
37
-
}
38
-
| Push(_) => ()
39
-
}
40
-
});
41
-
}));
47
+
);
48
+
})
49
+
);
+11
-11
src/web/wonka_sink_toPromise.re
+11
-11
src/web/wonka_sink_toPromise.re
···
1
1
open Wonka_types;
2
2
3
3
let toPromise = source => {
4
-
open Wonka_operator_takeLast;
5
-
6
-
Js.Promise.make((~resolve, ~reject as _) => {
7
-
takeLast(1, source, (.signal) => {
8
-
switch (signal) {
9
-
| Start(x) => x(.Pull)
10
-
| Push(x) => resolve(.x)
11
-
| End => ()
12
-
}
13
-
});
14
-
});
4
+
Wonka_operator_takeLast.(
5
+
Js.Promise.make((~resolve, ~reject as _) =>
6
+
takeLast(1, source, (. signal) =>
7
+
switch (signal) {
8
+
| Start(x) => x(. Pull)
9
+
| Push(x) => resolve(. x)
10
+
| End => ()
11
+
}
12
+
)
13
+
)
14
+
);
15
15
};
+16
-19
src/web/wonka_source_fromDomEvent.re
+16
-19
src/web/wonka_source_fromDomEvent.re
···
1
1
open Wonka_types;
2
2
open Wonka_source_fromListener;
3
3
4
-
let fromDomEvent = (element, event) => curry(sink => {
5
-
let addEventListener: (
6
-
Dom.element,
7
-
string,
8
-
(Dom.event) => unit
9
-
) => unit = [%raw {|
4
+
let fromDomEvent = (element, event) =>
5
+
curry(sink => {
6
+
let addEventListener: (Dom.element, string, Dom.event => unit) => unit = [%raw
7
+
{|
10
8
function (element, event, handler) {
11
9
element.addEventListener(event, handler);
12
10
}
13
-
|}];
11
+
|}
12
+
];
14
13
15
-
let removeEventListener: (
16
-
Dom.element,
17
-
string,
18
-
(Dom.event) => unit
19
-
) => unit = [%raw {|
14
+
let removeEventListener: (Dom.element, string, Dom.event => unit) => unit = [%raw
15
+
{|
20
16
function (element, event, handler) {
21
17
element.removeEventListener(event, handler);
22
18
}
23
-
|}];
19
+
|}
20
+
];
24
21
25
-
fromListener(
26
-
handler => addEventListener(element, event, handler),
27
-
handler => removeEventListener(element, event, handler),
28
-
sink
29
-
)
30
-
});
22
+
fromListener(
23
+
handler => addEventListener(element, event, handler),
24
+
handler => removeEventListener(element, event, handler),
25
+
sink,
26
+
);
27
+
});
+14
-10
src/web/wonka_source_fromListener.re
+14
-10
src/web/wonka_source_fromListener.re
···
1
1
open Wonka_types;
2
2
3
-
let fromListener = (addListener, removeListener) => curry(sink => {
4
-
let handler = event => sink(.Push(event));
3
+
let fromListener = (addListener, removeListener) =>
4
+
curry(sink => {
5
+
let handler = event => sink(. Push(event));
5
6
6
-
sink(.Start((.signal) => {
7
-
switch (signal) {
8
-
| Close => removeListener(handler)
9
-
| _ => ()
10
-
}
11
-
}));
7
+
sink(.
8
+
Start(
9
+
(. signal) =>
10
+
switch (signal) {
11
+
| Close => removeListener(handler)
12
+
| _ => ()
13
+
},
14
+
),
15
+
);
12
16
13
-
addListener(handler);
14
-
});
17
+
addListener(handler);
18
+
});
+25
-16
src/web/wonka_source_fromPromise.re
+25
-16
src/web/wonka_source_fromPromise.re
···
1
1
open Wonka_types;
2
2
3
-
let fromPromise = promise => curry(sink => {
4
-
let ended = ref(false);
3
+
let fromPromise = promise =>
4
+
curry(sink => {
5
+
let ended = ref(false);
5
6
6
-
ignore(Js.Promise.then_(value => {
7
-
if (!ended^) {
8
-
sink(.Push(value));
9
-
sink(.End);
10
-
};
7
+
ignore(
8
+
Js.Promise.then_(
9
+
value => {
10
+
if (! ended^) {
11
+
sink(. Push(value));
12
+
sink(. End);
13
+
};
11
14
12
-
Js.Promise.resolve(())
13
-
}, promise));
15
+
Js.Promise.resolve();
16
+
},
17
+
promise,
18
+
),
19
+
);
14
20
15
-
sink(.Start((.signal) => {
16
-
switch (signal) {
17
-
| Close => ended := true
18
-
| _ => ()
19
-
}
20
-
}));
21
-
});
21
+
sink(.
22
+
Start(
23
+
(. signal) =>
24
+
switch (signal) {
25
+
| Close => ended := true
26
+
| _ => ()
27
+
},
28
+
),
29
+
);
30
+
});
+31
-26
src/wonka_helpers.re
+31
-26
src/wonka_helpers.re
···
1
1
open Wonka_types;
2
2
3
-
let talkbackPlaceholder = (._: talkbackT) => ();
3
+
let talkbackPlaceholder = (. _: talkbackT) => ();
4
4
5
-
let captureTalkback = (
6
-
source: sourceT('a),
7
-
sinkWithTalkback: (.signalT('a), (.talkbackT) => unit) => unit
8
-
) => {
5
+
let captureTalkback =
6
+
(
7
+
source: sourceT('a),
8
+
sinkWithTalkback: (. signalT('a), (. talkbackT) => unit) => unit,
9
+
) => {
9
10
let talkback = ref(talkbackPlaceholder);
10
11
11
-
source((.signal) => {
12
+
source((. signal) => {
12
13
switch (signal) {
13
14
| Start(x) => talkback := x
14
15
| _ => ()
15
16
};
16
17
17
-
sinkWithTalkback(.signal, talkback^)
18
+
sinkWithTalkback(. signal, talkback^);
18
19
});
19
20
};
20
21
21
22
type trampolineT = {
22
23
mutable exhausted: bool,
23
24
mutable inLoop: bool,
24
-
mutable gotSignal: bool
25
+
mutable gotSignal: bool,
25
26
};
26
27
27
-
let makeTrampoline = (sink: sinkT('a), f: (.unit) => option('a)) => {
28
+
let makeTrampoline = (sink: sinkT('a), f: (. unit) => option('a)) => {
28
29
let state: trampolineT = {
29
30
exhausted: false,
30
31
inLoop: false,
31
-
gotSignal: false
32
+
gotSignal: false,
32
33
};
33
34
34
35
let loop = () => {
35
36
let rec explode = () =>
36
37
switch (f(.)) {
37
-
| Some(x) => {
38
+
| Some(x) =>
38
39
state.gotSignal = false;
39
-
sink(.Push(x));
40
-
if (state.gotSignal) explode();
41
-
}
42
-
| None => {
40
+
sink(. Push(x));
41
+
if (state.gotSignal) {
42
+
explode();
43
+
};
44
+
| None =>
43
45
state.exhausted = true;
44
-
sink(.End)
45
-
}
46
+
sink(. End);
46
47
};
47
48
48
49
state.inLoop = true;
···
50
51
state.inLoop = false;
51
52
};
52
53
53
-
sink(.Start((.signal) => {
54
-
switch (signal, state.exhausted) {
55
-
| (Pull, false) => {
56
-
state.gotSignal = true;
57
-
if (!state.inLoop) loop();
58
-
}
59
-
| _ => ()
60
-
}
61
-
}));
54
+
sink(.
55
+
Start(
56
+
(. signal) =>
57
+
switch (signal, state.exhausted) {
58
+
| (Pull, false) =>
59
+
state.gotSignal = true;
60
+
if (!state.inLoop) {
61
+
loop();
62
+
};
63
+
| _ => ()
64
+
},
65
+
),
66
+
);
62
67
};
+6
-8
src/wonka_types.re
+6
-8
src/wonka_types.re
···
31
31
| Close;
32
32
33
33
type signalT('a) =
34
-
| Start((.talkbackT) => unit)
34
+
| Start((. talkbackT) => unit)
35
35
| Push('a)
36
36
| End;
37
37
38
-
type sinkT('a) = (.signalT('a)) => unit;
38
+
type sinkT('a) = (. signalT('a)) => unit;
39
39
type sourceT('a) = sinkT('a) => unit;
40
40
41
-
type teardownT = (.unit) => unit;
41
+
type teardownT = (. unit) => unit;
42
42
43
-
type subscriptionT = {
44
-
unsubscribe: unit => unit
45
-
};
43
+
type subscriptionT = {unsubscribe: unit => unit};
46
44
47
45
type observerT('a) = {
48
46
next: 'a => unit,
49
-
complete: unit => unit
47
+
complete: unit => unit,
50
48
};
51
49
52
50
type subjectT('a) = {
53
51
source: sourceT('a),
54
52
next: 'a => unit,
55
-
complete: unit => unit
53
+
complete: unit => unit,
56
54
};
57
55
58
56
/* Sinks and sources need to explicitly be their own callbacks;
+563
-10
yarn.lock
+563
-10
yarn.lock
···
156
156
core-js "^2.5.7"
157
157
regenerator-runtime "^0.12.0"
158
158
159
+
"@babel/runtime@7.0.0":
160
+
version "7.0.0"
161
+
resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.0.0.tgz#adeb78fedfc855aa05bc041640f3f6f98e85424c"
162
+
integrity sha512-7hGhzlcmg01CvH1EHdSPVXYX1aJ8KCEyz6I9xYIi/asDtzBPMyMhVibhM/K6g/5qnKBwjZtp10bNZIEFTRW1MA==
163
+
dependencies:
164
+
regenerator-runtime "^0.12.0"
165
+
159
166
"@babel/template@^7.1.0", "@babel/template@^7.1.2", "@babel/template@^7.2.2":
160
167
version "7.2.2"
161
168
resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.2.2.tgz#005b3fdf0ed96e88041330379e0da9a708eb2907"
···
195
202
integrity sha512-TJLx1ti1Cp7e53bCndV7DpMAcZL9+pqA4L9YD4kCrDQuYdA8boRnPh1l862w8AJHWTxEki/xtDu0FVPCq2HVrA==
196
203
dependencies:
197
204
jest "^23.5.0"
205
+
206
+
"@samverschueren/stream-to-observable@^0.3.0":
207
+
version "0.3.0"
208
+
resolved "https://registry.yarnpkg.com/@samverschueren/stream-to-observable/-/stream-to-observable-0.3.0.tgz#ecdf48d532c58ea477acfcab80348424f8d0662f"
209
+
integrity sha512-MI4Xx6LHs4Webyvi6EbspgyAb4D2Q2VtnCQ1blOJcoLS6mVa8lNN2rkIy1CVxfTUpoyIbCTkXES1rLXztFD1lg==
210
+
dependencies:
211
+
any-observable "^0.3.0"
198
212
199
213
"@types/estree@0.0.39":
200
214
version "0.0.39"
···
286
300
dependencies:
287
301
color-convert "^1.9.0"
288
302
303
+
any-observable@^0.3.0:
304
+
version "0.3.0"
305
+
resolved "https://registry.yarnpkg.com/any-observable/-/any-observable-0.3.0.tgz#af933475e5806a67d0d7df090dd5e8bef65d119b"
306
+
integrity sha512-/FQM1EDkTsf63Ub2C6O7GuYFDsSXUwsaZDurV0np41ocwq0jthUAYCmhBX9f+KwlaCgIuWyr/4WlUQUBfKfZog==
307
+
289
308
anymatch@^2.0.0:
290
309
version "2.0.0"
291
310
resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-2.0.0.tgz#bcb24b4f37934d9aa7ac17b4adaf89e7c76ef2eb"
···
362
381
version "0.0.0"
363
382
resolved "https://registry.yarnpkg.com/array-reduce/-/array-reduce-0.0.0.tgz#173899d3ffd1c7d9383e4479525dbe278cab5f2b"
364
383
integrity sha1-FziZ0//Rx9k4PkR5Ul2+J4yrXys=
384
+
385
+
array-union@^1.0.1:
386
+
version "1.0.2"
387
+
resolved "https://registry.yarnpkg.com/array-union/-/array-union-1.0.2.tgz#9a34410e4f4e3da23dea375be5be70f24778ec39"
388
+
integrity sha1-mjRBDk9OPaI96jdb5b5w8kd47Dk=
389
+
dependencies:
390
+
array-uniq "^1.0.1"
391
+
392
+
array-uniq@^1.0.1:
393
+
version "1.0.3"
394
+
resolved "https://registry.yarnpkg.com/array-uniq/-/array-uniq-1.0.3.tgz#af6ac877a25cc7f74e058894753858dfdb24fdb6"
395
+
integrity sha1-r2rId6Jcx/dOBYiUdThY39sk/bY=
365
396
366
397
array-unique@^0.2.1:
367
398
version "0.2.1"
···
964
995
strip-ansi "^3.0.0"
965
996
supports-color "^2.0.0"
966
997
967
-
chalk@^2.0.0, chalk@^2.0.1, chalk@^2.4.0, chalk@^2.4.1, chalk@^2.4.2:
998
+
chalk@^2.0.0, chalk@^2.0.1, chalk@^2.3.1, chalk@^2.4.0, chalk@^2.4.1, chalk@^2.4.2:
968
999
version "2.4.2"
969
1000
resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
970
1001
integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
···
988
1019
resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-1.6.0.tgz#2ca20dbb9ceb32d4524a683303313f0304b1e497"
989
1020
integrity sha512-vsGdkwSCDpWmP80ncATX7iea5DWQemg1UgCW5J8tqjU3lYw4FBYuj89J0CTVomA7BEfvSZd84GmHko+MxFQU2A==
990
1021
1022
+
ci-info@^2.0.0:
1023
+
version "2.0.0"
1024
+
resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-2.0.0.tgz#67a9e964be31a51e15e5010d58e6f12834002f46"
1025
+
integrity sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==
1026
+
991
1027
clap@^1.0.9:
992
1028
version "1.2.3"
993
1029
resolved "https://registry.yarnpkg.com/clap/-/clap-1.2.3.tgz#4f36745b32008492557f46412d66d50cb99bce51"
···
1004
1040
define-property "^0.2.5"
1005
1041
isobject "^3.0.0"
1006
1042
static-extend "^0.1.1"
1043
+
1044
+
cli-cursor@^2.0.0, cli-cursor@^2.1.0:
1045
+
version "2.1.0"
1046
+
resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-2.1.0.tgz#b35dac376479facc3e94747d41d0d0f5238ffcb5"
1047
+
integrity sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=
1048
+
dependencies:
1049
+
restore-cursor "^2.0.0"
1050
+
1051
+
cli-truncate@^0.2.1:
1052
+
version "0.2.1"
1053
+
resolved "https://registry.yarnpkg.com/cli-truncate/-/cli-truncate-0.2.1.tgz#9f15cfbb0705005369216c626ac7d05ab90dd574"
1054
+
integrity sha1-nxXPuwcFAFNpIWxiasfQWrkN1XQ=
1055
+
dependencies:
1056
+
slice-ansi "0.0.4"
1057
+
string-width "^1.0.1"
1007
1058
1008
1059
cliui@^4.0.0:
1009
1060
version "4.1.0"
···
1128
1179
resolved "https://registry.yarnpkg.com/commander/-/commander-2.19.0.tgz#f6198aa84e5b83c46054b94ddedbfed5ee9ff12a"
1129
1180
integrity sha512-6tvAOO+D6OENvRAh524Dh9jcfKTYDQAqvqezbCW82xj5X0pSrcpxtvRKHLG0yBY6SD7PSDrJaj+0AiOcKVd1Xg==
1130
1181
1182
+
commander@^2.14.1, commander@^2.9.0:
1183
+
version "2.20.0"
1184
+
resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.0.tgz#d58bb2b5c1ee8f87b0d340027e9e94e222c5a422"
1185
+
integrity sha512-7j2y+40w61zy6YC2iRNpUe/NwhNyoXrYpHMrSunaMG64nRnaf96zO/KMQR4OyN/UnE5KLyEBnKHd4aG3rskjpQ==
1186
+
1131
1187
commander@~2.17.1:
1132
1188
version "2.17.1"
1133
1189
resolved "https://registry.yarnpkg.com/commander/-/commander-2.17.1.tgz#bd77ab7de6de94205ceacc72f1716d29f20a77bf"
···
1200
1256
js-yaml "^3.9.0"
1201
1257
parse-json "^4.0.0"
1202
1258
1259
+
cosmiconfig@^5.0.2, cosmiconfig@^5.0.7:
1260
+
version "5.2.0"
1261
+
resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-5.2.0.tgz#45038e4d28a7fe787203aede9c25bca4a08b12c8"
1262
+
integrity sha512-nxt+Nfc3JAqf4WIWd0jXLjTJZmsPLrA9DDc4nRw2KFJQJK7DNooqSXrNI7tzLG50CF8axczly5UV929tBmh/7g==
1263
+
dependencies:
1264
+
import-fresh "^2.0.0"
1265
+
is-directory "^0.3.1"
1266
+
js-yaml "^3.13.0"
1267
+
parse-json "^4.0.0"
1268
+
1203
1269
coveralls@^3.0.0:
1204
1270
version "3.0.2"
1205
1271
resolved "https://registry.yarnpkg.com/coveralls/-/coveralls-3.0.2.tgz#f5a0bcd90ca4e64e088b710fa8dda640aea4884f"
···
1221
1287
shebang-command "^1.2.0"
1222
1288
which "^1.2.9"
1223
1289
1224
-
cross-spawn@^6.0.5:
1290
+
cross-spawn@^6.0.0, cross-spawn@^6.0.5:
1225
1291
version "6.0.5"
1226
1292
resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4"
1227
1293
integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==
···
1471
1537
whatwg-mimetype "^2.2.0"
1472
1538
whatwg-url "^7.0.0"
1473
1539
1540
+
date-fns@^1.27.2:
1541
+
version "1.30.1"
1542
+
resolved "https://registry.yarnpkg.com/date-fns/-/date-fns-1.30.1.tgz#2e71bf0b119153dbb4cc4e88d9ea5acfb50dc05c"
1543
+
integrity sha512-hBSVCvSmWC+QypYObzwGOd9wqdDpOt+0wl0KbU+R+uuZBS1jN8VsD1ss3irQDknRj5NvxiTF6oj/nDRnN/UQNw==
1544
+
1474
1545
debug@=3.1.0:
1475
1546
version "3.1.0"
1476
1547
resolved "https://registry.yarnpkg.com/debug/-/debug-3.1.0.tgz#5bb5a0672628b64149566ba16819e61518c67261"
···
1492
1563
dependencies:
1493
1564
ms "^2.1.1"
1494
1565
1495
-
debug@^4.1.0:
1566
+
debug@^4.0.1, debug@^4.1.0:
1496
1567
version "4.1.1"
1497
1568
resolved "https://registry.yarnpkg.com/debug/-/debug-4.1.1.tgz#3b72260255109c6b589cee050f1d516139664791"
1498
1569
integrity sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==
···
1516
1587
dependencies:
1517
1588
mimic-response "^1.0.0"
1518
1589
1590
+
dedent@^0.7.0:
1591
+
version "0.7.0"
1592
+
resolved "https://registry.yarnpkg.com/dedent/-/dedent-0.7.0.tgz#2495ddbaf6eb874abb0e1be9df22d2e5a544326c"
1593
+
integrity sha1-JJXduvbrh0q7Dhvp3yLS5aVEMmw=
1594
+
1519
1595
deep-extend@^0.6.0:
1520
1596
version "0.6.0"
1521
1597
resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.6.0.tgz#c4fa7c95404a17a9c3e8ca7e1537312b736330ac"
···
1567
1643
resolved "https://registry.yarnpkg.com/defined/-/defined-1.0.0.tgz#c98d9bcef75674188e110969151199e39b1fa693"
1568
1644
integrity sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=
1569
1645
1646
+
del@^3.0.0:
1647
+
version "3.0.0"
1648
+
resolved "https://registry.yarnpkg.com/del/-/del-3.0.0.tgz#53ecf699ffcbcb39637691ab13baf160819766e5"
1649
+
integrity sha1-U+z2mf/LyzljdpGrE7rxYIGXZuU=
1650
+
dependencies:
1651
+
globby "^6.1.0"
1652
+
is-path-cwd "^1.0.0"
1653
+
is-path-in-cwd "^1.0.0"
1654
+
p-map "^1.1.1"
1655
+
pify "^3.0.0"
1656
+
rimraf "^2.2.8"
1657
+
1570
1658
delayed-stream@~1.0.0:
1571
1659
version "1.0.0"
1572
1660
resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
···
1661
1749
version "1.3.102"
1662
1750
resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.102.tgz#3ac43a037c8a63bca3dfa189eb3d90f097196787"
1663
1751
integrity sha512-2nzZuXw/KBPnI3QX3UOCSRvJiVy7o9+VHRDQ3D/EHCvVc89X6aj/GlNmEgiR2GBIhmSWXIi4W1M5okA5ScSlNg==
1752
+
1753
+
elegant-spinner@^1.0.1:
1754
+
version "1.0.1"
1755
+
resolved "https://registry.yarnpkg.com/elegant-spinner/-/elegant-spinner-1.0.1.tgz#db043521c95d7e303fd8f345bedc3349cfb0729e"
1756
+
integrity sha1-2wQ1IcldfjA/2PNFvtwzSc+wcp4=
1664
1757
1665
1758
emojis-list@^2.0.0:
1666
1759
version "2.1.0"
···
1712
1805
resolved "https://registry.yarnpkg.com/es6-promisify/-/es6-promisify-6.0.1.tgz#6edaa45f3bd570ffe08febce66f7116be4b1cdb6"
1713
1806
integrity sha512-J3ZkwbEnnO+fGAKrjVpeUAnZshAdfZvbhQpqfIH9kSAspReRC4nJnu8ewm55b4y9ElyeuhCTzJD0XiH8Tsbhlw==
1714
1807
1715
-
escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.5:
1808
+
escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.4, escape-string-regexp@^1.0.5:
1716
1809
version "1.0.5"
1717
1810
resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
1718
1811
integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=
···
1784
1877
signal-exit "^3.0.0"
1785
1878
strip-eof "^1.0.0"
1786
1879
1880
+
execa@^1.0.0:
1881
+
version "1.0.0"
1882
+
resolved "https://registry.yarnpkg.com/execa/-/execa-1.0.0.tgz#c6236a5bb4df6d6f15e88e7f017798216749ddd8"
1883
+
integrity sha512-adbxcyWV46qiHyvSp50TKt05tB4tK3HcmF7/nxfAdhnox83seTDbwnaqKO4sXRy7roHAIFqJP/Rw/AuEbX61LA==
1884
+
dependencies:
1885
+
cross-spawn "^6.0.0"
1886
+
get-stream "^4.0.0"
1887
+
is-stream "^1.1.0"
1888
+
npm-run-path "^2.0.0"
1889
+
p-finally "^1.0.0"
1890
+
signal-exit "^3.0.0"
1891
+
strip-eof "^1.0.0"
1892
+
1787
1893
exit@^0.1.2:
1788
1894
version "0.1.2"
1789
1895
resolved "https://registry.yarnpkg.com/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c"
···
1916
2022
dependencies:
1917
2023
bser "^2.0.0"
1918
2024
1919
-
figures@^1.0.1:
2025
+
figures@^1.0.1, figures@^1.7.0:
1920
2026
version "1.7.0"
1921
2027
resolved "https://registry.yarnpkg.com/figures/-/figures-1.7.0.tgz#cbe1e3affcf1cd44b80cadfed28dc793a9701d2e"
1922
2028
integrity sha1-y+Hjr/zxzUS4DK3+0o3Hk6lwHS4=
1923
2029
dependencies:
1924
2030
escape-string-regexp "^1.0.5"
1925
2031
object-assign "^4.1.0"
2032
+
2033
+
figures@^2.0.0:
2034
+
version "2.0.0"
2035
+
resolved "https://registry.yarnpkg.com/figures/-/figures-2.0.0.tgz#3ab1a2d2a62c8bfb431a0c94cb797a2fce27c962"
2036
+
integrity sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=
2037
+
dependencies:
2038
+
escape-string-regexp "^1.0.5"
1926
2039
1927
2040
filename-regex@^2.0.0:
1928
2041
version "2.0.1"
···
1963
2076
repeat-string "^1.6.1"
1964
2077
to-regex-range "^2.1.0"
1965
2078
2079
+
find-parent-dir@^0.3.0:
2080
+
version "0.3.0"
2081
+
resolved "https://registry.yarnpkg.com/find-parent-dir/-/find-parent-dir-0.3.0.tgz#33c44b429ab2b2f0646299c5f9f718f376ff8d54"
2082
+
integrity sha1-M8RLQpqysvBkYpnF+fcY83b/jVQ=
2083
+
1966
2084
find-up@^1.0.0:
1967
2085
version "1.1.2"
1968
2086
resolved "https://registry.yarnpkg.com/find-up/-/find-up-1.1.2.tgz#6b2e9822b1a2ce0a60ab64d610eccad53cb24d0f"
···
1978
2096
dependencies:
1979
2097
locate-path "^2.0.0"
1980
2098
2099
+
find-up@^3.0.0:
2100
+
version "3.0.0"
2101
+
resolved "https://registry.yarnpkg.com/find-up/-/find-up-3.0.0.tgz#49169f1d7993430646da61ecc5ae355c21c97b73"
2102
+
integrity sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==
2103
+
dependencies:
2104
+
locate-path "^3.0.0"
2105
+
1981
2106
flatten@^1.0.2:
1982
2107
version "1.0.2"
1983
2108
resolved "https://registry.yarnpkg.com/flatten/-/flatten-1.0.2.tgz#dae46a9d78fbe25292258cc1e780a41d95c03782"
···
1990
2115
dependencies:
1991
2116
babylon "^6.15.0"
1992
2117
vlq "^0.2.1"
2118
+
2119
+
fn-name@~2.0.1:
2120
+
version "2.0.1"
2121
+
resolved "https://registry.yarnpkg.com/fn-name/-/fn-name-2.0.1.tgz#5214d7537a4d06a4a301c0cc262feb84188002e7"
2122
+
integrity sha1-UhTXU3pNBqSjAcDMJi/rhBiAAuc=
1993
2123
1994
2124
follow-redirects@1.0.0:
1995
2125
version "1.0.0"
···
2096
2226
resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
2097
2227
integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
2098
2228
2229
+
g-status@^2.0.2:
2230
+
version "2.0.2"
2231
+
resolved "https://registry.yarnpkg.com/g-status/-/g-status-2.0.2.tgz#270fd32119e8fc9496f066fe5fe88e0a6bc78b97"
2232
+
integrity sha512-kQoE9qH+T1AHKgSSD0Hkv98bobE90ILQcXAF4wvGgsr7uFqNvwmh8j+Lq3l0RVt3E3HjSbv2B9biEGcEtpHLCA==
2233
+
dependencies:
2234
+
arrify "^1.0.1"
2235
+
matcher "^1.0.0"
2236
+
simple-git "^1.85.0"
2237
+
2099
2238
gauge@~2.7.3:
2100
2239
version "2.7.4"
2101
2240
resolved "https://registry.yarnpkg.com/gauge/-/gauge-2.7.4.tgz#2c03405c7538c39d7eb37b317022e325fb018bf7"
···
2122
2261
resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-1.0.3.tgz#f978fa4c90d1dfe7ff2d6beda2a515e713bdcf4a"
2123
2262
integrity sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w==
2124
2263
2264
+
get-own-enumerable-property-symbols@^3.0.0:
2265
+
version "3.0.0"
2266
+
resolved "https://registry.yarnpkg.com/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.0.tgz#b877b49a5c16aefac3655f2ed2ea5b684df8d203"
2267
+
integrity sha512-CIJYJC4GGF06TakLg8z4GQKvDsx9EMspVxOYih7LerEL/WosUnFIww45CGfxfeKHqlg3twgUrYRT1O3WQqjGCg==
2268
+
2269
+
get-stdin@^6.0.0:
2270
+
version "6.0.0"
2271
+
resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-6.0.0.tgz#9e09bf712b360ab9225e812048f71fde9c89657b"
2272
+
integrity sha512-jp4tHawyV7+fkkSKyvjuLZswblUtz+SQKzSWnBbii16BuZksJlU1wuBYXY75r+duh/llF1ur6oNwi+2ZzjKZ7g==
2273
+
2125
2274
get-stream@^3.0.0:
2126
2275
version "3.0.0"
2127
2276
resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-3.0.0.tgz#8e943d1358dc37555054ecbe2edb05aa174ede14"
2128
2277
integrity sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=
2278
+
2279
+
get-stream@^4.0.0:
2280
+
version "4.1.0"
2281
+
resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-4.1.0.tgz#c1b255575f3dc21d59bfc79cd3d2b46b1c3a54b5"
2282
+
integrity sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==
2283
+
dependencies:
2284
+
pump "^3.0.0"
2129
2285
2130
2286
get-value@^2.0.3, get-value@^2.0.6:
2131
2287
version "2.0.6"
···
2192
2348
version "0.1.0"
2193
2349
resolved "https://registry.yarnpkg.com/globalyzer/-/globalyzer-0.1.0.tgz#cb76da79555669a1519d5a8edf093afaa0bf1465"
2194
2350
integrity sha512-40oNTM9UfG6aBmuKxk/giHn5nQ8RVz/SS4Ir6zgzOv9/qC3kKZ9v4etGTcJbEl/NyVQH7FGU7d+X1egr57Md2Q==
2351
+
2352
+
globby@^6.1.0:
2353
+
version "6.1.0"
2354
+
resolved "https://registry.yarnpkg.com/globby/-/globby-6.1.0.tgz#f5a6d70e8395e21c858fb0489d64df02424d506c"
2355
+
integrity sha1-9abXDoOV4hyFj7BInWTfAkJNUGw=
2356
+
dependencies:
2357
+
array-union "^1.0.1"
2358
+
glob "^7.0.3"
2359
+
object-assign "^4.0.1"
2360
+
pify "^2.0.0"
2361
+
pinkie-promise "^2.0.0"
2195
2362
2196
2363
globrex@^0.1.1:
2197
2364
version "0.1.2"
···
2379
2546
jsprim "^1.2.2"
2380
2547
sshpk "^1.7.0"
2381
2548
2549
+
husky@^1.3.1:
2550
+
version "1.3.1"
2551
+
resolved "https://registry.yarnpkg.com/husky/-/husky-1.3.1.tgz#26823e399300388ca2afff11cfa8a86b0033fae0"
2552
+
integrity sha512-86U6sVVVf4b5NYSZ0yvv88dRgBSSXXmHaiq5pP4KDj5JVzdwKgBjEtUPOm8hcoytezFwbU+7gotXNhpHdystlg==
2553
+
dependencies:
2554
+
cosmiconfig "^5.0.7"
2555
+
execa "^1.0.0"
2556
+
find-up "^3.0.0"
2557
+
get-stdin "^6.0.0"
2558
+
is-ci "^2.0.0"
2559
+
pkg-dir "^3.0.0"
2560
+
please-upgrade-node "^3.1.1"
2561
+
read-pkg "^4.0.1"
2562
+
run-node "^1.0.0"
2563
+
slash "^2.0.0"
2564
+
2382
2565
iconv-lite@0.4.24, iconv-lite@^0.4.4:
2383
2566
version "0.4.24"
2384
2567
resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
···
2452
2635
version "0.1.4"
2453
2636
resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
2454
2637
integrity sha1-khi5srkoojixPcT7a21XbyMUU+o=
2638
+
2639
+
indent-string@^3.0.0:
2640
+
version "3.2.0"
2641
+
resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-3.2.0.tgz#4a5fd6d27cc332f37e5419a504dbb837105c9289"
2642
+
integrity sha1-Sl/W0nzDMvN+VBmlBNu4NxBckok=
2455
2643
2456
2644
indexes-of@^1.0.1:
2457
2645
version "1.0.1"
···
2546
2734
dependencies:
2547
2735
ci-info "^1.5.0"
2548
2736
2737
+
is-ci@^2.0.0:
2738
+
version "2.0.0"
2739
+
resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-2.0.0.tgz#6bc6334181810e04b5c22b3d589fdca55026404c"
2740
+
integrity sha512-YfJT7rkpQB0updsdHLGWrvhBJfcfzNNawYDNIyQXJz0IViGf75O8EBPKSdvw2rF+LGCsX4FZ8tcr3b19LcZq4w==
2741
+
dependencies:
2742
+
ci-info "^2.0.0"
2743
+
2549
2744
is-color-stop@^1.0.0:
2550
2745
version "1.1.0"
2551
2746
resolved "https://registry.yarnpkg.com/is-color-stop/-/is-color-stop-1.1.0.tgz#cfff471aee4dd5c9e158598fbe12967b5cdad345"
···
2629
2824
resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-1.0.0.tgz#ac468177c4943405a092fc8f29760c6ffc6206c0"
2630
2825
integrity sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=
2631
2826
2827
+
is-extglob@^2.1.1:
2828
+
version "2.1.1"
2829
+
resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
2830
+
integrity sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=
2831
+
2632
2832
is-finite@^1.0.0:
2633
2833
version "1.0.2"
2634
2834
resolved "https://registry.yarnpkg.com/is-finite/-/is-finite-1.0.2.tgz#cc6677695602be550ef11e8b4aa6305342b6d0aa"
···
2660
2860
dependencies:
2661
2861
is-extglob "^1.0.0"
2662
2862
2863
+
is-glob@^4.0.0:
2864
+
version "4.0.1"
2865
+
resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.1.tgz#7567dbe9f2f5e2467bc77ab83c4a29482407a5dc"
2866
+
integrity sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==
2867
+
dependencies:
2868
+
is-extglob "^2.1.1"
2869
+
2663
2870
is-module@^1.0.0:
2664
2871
version "1.0.0"
2665
2872
resolved "https://registry.yarnpkg.com/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591"
···
2684
2891
resolved "https://registry.yarnpkg.com/is-number/-/is-number-4.0.0.tgz#0026e37f5454d73e356dfe6564699867c6a7f0ff"
2685
2892
integrity sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==
2686
2893
2687
-
is-obj@^1.0.0:
2894
+
is-obj@^1.0.0, is-obj@^1.0.1:
2688
2895
version "1.0.1"
2689
2896
resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-1.0.1.tgz#3e4729ac1f5fde025cd7d83a896dab9f4f67db0f"
2690
2897
integrity sha1-PkcprB9f3gJc19g6iW2rn09n2w8=
2691
2898
2899
+
is-observable@^1.1.0:
2900
+
version "1.1.0"
2901
+
resolved "https://registry.yarnpkg.com/is-observable/-/is-observable-1.1.0.tgz#b3e986c8f44de950867cab5403f5a3465005975e"
2902
+
integrity sha512-NqCa4Sa2d+u7BWc6CukaObG3Fh+CU9bvixbpcXYhy2VvYS7vVGIdAgnIS5Ks3A/cqk4rebLJ9s8zBstT2aKnIA==
2903
+
dependencies:
2904
+
symbol-observable "^1.1.0"
2905
+
2906
+
is-path-cwd@^1.0.0:
2907
+
version "1.0.0"
2908
+
resolved "https://registry.yarnpkg.com/is-path-cwd/-/is-path-cwd-1.0.0.tgz#d225ec23132e89edd38fda767472e62e65f1106d"
2909
+
integrity sha1-0iXsIxMuie3Tj9p2dHLmLmXxEG0=
2910
+
2911
+
is-path-in-cwd@^1.0.0:
2912
+
version "1.0.1"
2913
+
resolved "https://registry.yarnpkg.com/is-path-in-cwd/-/is-path-in-cwd-1.0.1.tgz#5ac48b345ef675339bd6c7a48a912110b241cf52"
2914
+
integrity sha512-FjV1RTW48E7CWM7eE/J2NJvAEEVektecDBVBE5Hh3nM1Jd0kvhHtX68Pr3xsDf857xt3Y4AkwVULK1Vku62aaQ==
2915
+
dependencies:
2916
+
is-path-inside "^1.0.0"
2917
+
2918
+
is-path-inside@^1.0.0:
2919
+
version "1.0.1"
2920
+
resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-1.0.1.tgz#8ef5b7de50437a3fdca6b4e865ef7aa55cb48036"
2921
+
integrity sha1-jvW33lBDej/cprToZe96pVy0gDY=
2922
+
dependencies:
2923
+
path-is-inside "^1.0.1"
2924
+
2692
2925
is-plain-obj@^1.0.0:
2693
2926
version "1.1.0"
2694
2927
resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e"
···
2711
2944
resolved "https://registry.yarnpkg.com/is-primitive/-/is-primitive-2.0.0.tgz#207bab91638499c07b2adf240a41a87210034575"
2712
2945
integrity sha1-IHurkWOEmcB7Kt8kCkGochADRXU=
2713
2946
2947
+
is-promise@^2.1.0:
2948
+
version "2.1.0"
2949
+
resolved "https://registry.yarnpkg.com/is-promise/-/is-promise-2.1.0.tgz#79a2a9ece7f096e80f36d2b2f3bc16c1ff4bf3fa"
2950
+
integrity sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=
2951
+
2714
2952
is-regex@^1.0.4:
2715
2953
version "1.0.4"
2716
2954
resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.0.4.tgz#5517489b547091b0930e095654ced25ee97e9491"
2717
2955
integrity sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=
2718
2956
dependencies:
2719
2957
has "^1.0.1"
2958
+
2959
+
is-regexp@^1.0.0:
2960
+
version "1.0.0"
2961
+
resolved "https://registry.yarnpkg.com/is-regexp/-/is-regexp-1.0.0.tgz#fd2d883545c46bac5a633e7b9a09e87fa2cb5069"
2962
+
integrity sha1-/S2INUXEa6xaYz57mgnof6LLUGk=
2720
2963
2721
2964
is-resolvable@^1.0.0:
2722
2965
version "1.1.0"
···
3201
3444
argparse "^1.0.7"
3202
3445
esprima "^4.0.0"
3203
3446
3447
+
js-yaml@^3.13.0:
3448
+
version "3.13.1"
3449
+
resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.13.1.tgz#aff151b30bfdfa8e49e05da22e7415e9dfa37847"
3450
+
integrity sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==
3451
+
dependencies:
3452
+
argparse "^1.0.7"
3453
+
esprima "^4.0.0"
3454
+
3204
3455
js-yaml@~3.7.0:
3205
3456
version "3.7.0"
3206
3457
resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.7.0.tgz#5c967ddd837a9bfdca5f2de84253abe8a1c03b80"
···
3374
3625
prelude-ls "~1.1.2"
3375
3626
type-check "~0.3.2"
3376
3627
3628
+
lint-staged@^8.1.5:
3629
+
version "8.1.5"
3630
+
resolved "https://registry.yarnpkg.com/lint-staged/-/lint-staged-8.1.5.tgz#372476fe1a58b8834eb562ed4c99126bd60bdd79"
3631
+
integrity sha512-e5ZavfnSLcBJE1BTzRTqw6ly8OkqVyO3GL2M6teSmTBYQ/2BuueD5GIt2RPsP31u/vjKdexUyDCxSyK75q4BDA==
3632
+
dependencies:
3633
+
chalk "^2.3.1"
3634
+
commander "^2.14.1"
3635
+
cosmiconfig "^5.0.2"
3636
+
debug "^3.1.0"
3637
+
dedent "^0.7.0"
3638
+
del "^3.0.0"
3639
+
execa "^1.0.0"
3640
+
find-parent-dir "^0.3.0"
3641
+
g-status "^2.0.2"
3642
+
is-glob "^4.0.0"
3643
+
is-windows "^1.0.2"
3644
+
listr "^0.14.2"
3645
+
listr-update-renderer "^0.5.0"
3646
+
lodash "^4.17.11"
3647
+
log-symbols "^2.2.0"
3648
+
micromatch "^3.1.8"
3649
+
npm-which "^3.0.1"
3650
+
p-map "^1.1.1"
3651
+
path-is-inside "^1.0.2"
3652
+
pify "^3.0.0"
3653
+
please-upgrade-node "^3.0.2"
3654
+
staged-git-files "1.1.2"
3655
+
string-argv "^0.0.2"
3656
+
stringify-object "^3.2.2"
3657
+
yup "^0.26.10"
3658
+
3659
+
listr-silent-renderer@^1.1.1:
3660
+
version "1.1.1"
3661
+
resolved "https://registry.yarnpkg.com/listr-silent-renderer/-/listr-silent-renderer-1.1.1.tgz#924b5a3757153770bf1a8e3fbf74b8bbf3f9242e"
3662
+
integrity sha1-kktaN1cVN3C/Go4/v3S4u/P5JC4=
3663
+
3664
+
listr-update-renderer@^0.5.0:
3665
+
version "0.5.0"
3666
+
resolved "https://registry.yarnpkg.com/listr-update-renderer/-/listr-update-renderer-0.5.0.tgz#4ea8368548a7b8aecb7e06d8c95cb45ae2ede6a2"
3667
+
integrity sha512-tKRsZpKz8GSGqoI/+caPmfrypiaq+OQCbd+CovEC24uk1h952lVj5sC7SqyFUm+OaJ5HN/a1YLt5cit2FMNsFA==
3668
+
dependencies:
3669
+
chalk "^1.1.3"
3670
+
cli-truncate "^0.2.1"
3671
+
elegant-spinner "^1.0.1"
3672
+
figures "^1.7.0"
3673
+
indent-string "^3.0.0"
3674
+
log-symbols "^1.0.2"
3675
+
log-update "^2.3.0"
3676
+
strip-ansi "^3.0.1"
3677
+
3678
+
listr-verbose-renderer@^0.5.0:
3679
+
version "0.5.0"
3680
+
resolved "https://registry.yarnpkg.com/listr-verbose-renderer/-/listr-verbose-renderer-0.5.0.tgz#f1132167535ea4c1261102b9f28dac7cba1e03db"
3681
+
integrity sha512-04PDPqSlsqIOaaaGZ+41vq5FejI9auqTInicFRndCBgE3bXG8D6W1I+mWhk+1nqbHmyhla/6BUrd5OSiHwKRXw==
3682
+
dependencies:
3683
+
chalk "^2.4.1"
3684
+
cli-cursor "^2.1.0"
3685
+
date-fns "^1.27.2"
3686
+
figures "^2.0.0"
3687
+
3688
+
listr@^0.14.2:
3689
+
version "0.14.3"
3690
+
resolved "https://registry.yarnpkg.com/listr/-/listr-0.14.3.tgz#2fea909604e434be464c50bddba0d496928fa586"
3691
+
integrity sha512-RmAl7su35BFd/xoMamRjpIE4j3v+L28o8CT5YhAXQJm1fD+1l9ngXY8JAQRJ+tFK2i5njvi0iRUKV09vPwA0iA==
3692
+
dependencies:
3693
+
"@samverschueren/stream-to-observable" "^0.3.0"
3694
+
is-observable "^1.1.0"
3695
+
is-promise "^2.1.0"
3696
+
is-stream "^1.1.0"
3697
+
listr-silent-renderer "^1.1.1"
3698
+
listr-update-renderer "^0.5.0"
3699
+
listr-verbose-renderer "^0.5.0"
3700
+
p-map "^2.0.0"
3701
+
rxjs "^6.3.3"
3702
+
3377
3703
load-json-file@^1.0.0:
3378
3704
version "1.1.0"
3379
3705
resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-1.1.0.tgz#956905708d58b4bab4c2261b04f59f31c99374c0"
···
3413
3739
p-locate "^2.0.0"
3414
3740
path-exists "^3.0.0"
3415
3741
3742
+
locate-path@^3.0.0:
3743
+
version "3.0.0"
3744
+
resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-3.0.0.tgz#dbec3b3ab759758071b58fe59fc41871af21400e"
3745
+
integrity sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==
3746
+
dependencies:
3747
+
p-locate "^3.0.0"
3748
+
path-exists "^3.0.0"
3749
+
3416
3750
lodash.camelcase@^4.3.0:
3417
3751
version "4.3.0"
3418
3752
resolved "https://registry.yarnpkg.com/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz#b28aa6288a2b9fc651035c7711f65ab6190331a6"
···
3443
3777
resolved "https://registry.yarnpkg.com/lodash.uniq/-/lodash.uniq-4.5.0.tgz#d0225373aeb652adc1bc82e4945339a842754773"
3444
3778
integrity sha1-0CJTc662Uq3BvILklFM5qEJ1R3M=
3445
3779
3446
-
lodash@^4.13.1, lodash@^4.17.10, lodash@^4.17.4:
3780
+
lodash@^4.13.1, lodash@^4.17.10, lodash@^4.17.11, lodash@^4.17.4:
3447
3781
version "4.17.11"
3448
3782
resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.11.tgz#b39ea6229ef607ecd89e2c8df12536891cac9b8d"
3449
3783
integrity sha512-cQKh8igo5QUhZ7lg38DYWAxMvjSAKG0A8wGSVimP07SIUEK2UO+arSRKbRZWtelMtN5V0Hkwh5ryOto/SshYIg==
···
3453
3787
resolved "https://registry.yarnpkg.com/log-driver/-/log-driver-1.2.7.tgz#63b95021f0702fedfa2c9bb0a24e7797d71871d8"
3454
3788
integrity sha512-U7KCmLdqsGHBLeWqYlFA0V0Sl6P08EE1ZrmA9cxjUE0WVqT9qnyVDPz1kzpFEP0jdJuFnasWIfSd7fsaNXkpbg==
3455
3789
3790
+
log-symbols@^1.0.2:
3791
+
version "1.0.2"
3792
+
resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-1.0.2.tgz#376ff7b58ea3086a0f09facc74617eca501e1a18"
3793
+
integrity sha1-N2/3tY6jCGoPCfrMdGF+ylAeGhg=
3794
+
dependencies:
3795
+
chalk "^1.0.0"
3796
+
3797
+
log-symbols@^2.2.0:
3798
+
version "2.2.0"
3799
+
resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-2.2.0.tgz#5740e1c5d6f0dfda4ad9323b5332107ef6b4c40a"
3800
+
integrity sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==
3801
+
dependencies:
3802
+
chalk "^2.0.1"
3803
+
3804
+
log-update@^2.3.0:
3805
+
version "2.3.0"
3806
+
resolved "https://registry.yarnpkg.com/log-update/-/log-update-2.3.0.tgz#88328fd7d1ce7938b29283746f0b1bc126b24708"
3807
+
integrity sha1-iDKP19HOeTiykoN0bwsbwSayRwg=
3808
+
dependencies:
3809
+
ansi-escapes "^3.0.0"
3810
+
cli-cursor "^2.0.0"
3811
+
wrap-ansi "^3.0.1"
3812
+
3456
3813
loose-envify@^1.0.0:
3457
3814
version "1.4.0"
3458
3815
resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz#71ee51fa7be4caec1a63839f7e682d8132d30caf"
···
3500
3857
integrity sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=
3501
3858
dependencies:
3502
3859
object-visit "^1.0.0"
3860
+
3861
+
matcher@^1.0.0:
3862
+
version "1.1.1"
3863
+
resolved "https://registry.yarnpkg.com/matcher/-/matcher-1.1.1.tgz#51d8301e138f840982b338b116bb0c09af62c1c2"
3864
+
integrity sha512-+BmqxWIubKTRKNWx/ahnCkk3mG8m7OturVlqq6HiojGJTd5hVYbgZm6WzcYPCoB+KBT4Vd6R7WSRG2OADNaCjg==
3865
+
dependencies:
3866
+
escape-string-regexp "^1.0.4"
3503
3867
3504
3868
math-expression-evaluator@^1.2.14:
3505
3869
version "1.2.17"
···
3607
3971
parse-glob "^3.0.4"
3608
3972
regex-cache "^0.4.2"
3609
3973
3610
-
micromatch@^3.1.4:
3974
+
micromatch@^3.1.4, micromatch@^3.1.8:
3611
3975
version "3.1.10"
3612
3976
resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-3.1.10.tgz#70859bc95c9840952f359a068a3fc49f9ecfac23"
3613
3977
integrity sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==
···
3899
4263
ignore-walk "^3.0.1"
3900
4264
npm-bundled "^1.0.1"
3901
4265
4266
+
npm-path@^2.0.2:
4267
+
version "2.0.4"
4268
+
resolved "https://registry.yarnpkg.com/npm-path/-/npm-path-2.0.4.tgz#c641347a5ff9d6a09e4d9bce5580c4f505278e64"
4269
+
integrity sha512-IFsj0R9C7ZdR5cP+ET342q77uSRdtWOlWpih5eC+lu29tIDbNEgDbzgVJ5UFvYHWhxDZ5TFkJafFioO0pPQjCw==
4270
+
dependencies:
4271
+
which "^1.2.10"
4272
+
3902
4273
npm-run-all@^4.1.5:
3903
4274
version "4.1.5"
3904
4275
resolved "https://registry.yarnpkg.com/npm-run-all/-/npm-run-all-4.1.5.tgz#04476202a15ee0e2e214080861bff12a51d98fba"
···
3921
4292
dependencies:
3922
4293
path-key "^2.0.0"
3923
4294
4295
+
npm-which@^3.0.1:
4296
+
version "3.0.1"
4297
+
resolved "https://registry.yarnpkg.com/npm-which/-/npm-which-3.0.1.tgz#9225f26ec3a285c209cae67c3b11a6b4ab7140aa"
4298
+
integrity sha1-kiXybsOihcIJyuZ8OxGmtKtxQKo=
4299
+
dependencies:
4300
+
commander "^2.9.0"
4301
+
npm-path "^2.0.2"
4302
+
which "^1.2.10"
4303
+
3924
4304
"npmlog@0 || 1 || 2 || 3 || 4", npmlog@^4.0.1, npmlog@^4.0.2, npmlog@^4.1.2:
3925
4305
version "4.1.2"
3926
4306
resolved "https://registry.yarnpkg.com/npmlog/-/npmlog-4.1.2.tgz#08a7f2a8bf734604779a9efa4ad5cc717abb954b"
···
4024
4404
dependencies:
4025
4405
wrappy "1"
4026
4406
4407
+
onetime@^2.0.0:
4408
+
version "2.0.1"
4409
+
resolved "https://registry.yarnpkg.com/onetime/-/onetime-2.0.1.tgz#067428230fd67443b2794b22bba528b6867962d4"
4410
+
integrity sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=
4411
+
dependencies:
4412
+
mimic-fn "^1.0.0"
4413
+
4027
4414
optimist@^0.6.1:
4028
4415
version "0.6.1"
4029
4416
resolved "https://registry.yarnpkg.com/optimist/-/optimist-0.6.1.tgz#da3ea74686fa21a19a111c326e90eb15a0196686"
···
4083
4470
dependencies:
4084
4471
p-try "^1.0.0"
4085
4472
4473
+
p-limit@^2.0.0:
4474
+
version "2.2.0"
4475
+
resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.2.0.tgz#417c9941e6027a9abcba5092dd2904e255b5fbc2"
4476
+
integrity sha512-pZbTJpoUsCzV48Mc9Nh51VbwO0X9cuPFE8gYwx9BTCt9SF8/b7Zljd2fVgOxhIF/HDTKgpVzs+GPhyKfjLLFRQ==
4477
+
dependencies:
4478
+
p-try "^2.0.0"
4479
+
4086
4480
p-locate@^2.0.0:
4087
4481
version "2.0.0"
4088
4482
resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43"
···
4090
4484
dependencies:
4091
4485
p-limit "^1.1.0"
4092
4486
4487
+
p-locate@^3.0.0:
4488
+
version "3.0.0"
4489
+
resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-3.0.0.tgz#322d69a05c0264b25997d9f40cd8a891ab0064a4"
4490
+
integrity sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==
4491
+
dependencies:
4492
+
p-limit "^2.0.0"
4493
+
4494
+
p-map@^1.1.1:
4495
+
version "1.2.0"
4496
+
resolved "https://registry.yarnpkg.com/p-map/-/p-map-1.2.0.tgz#e4e94f311eabbc8633a1e79908165fca26241b6b"
4497
+
integrity sha512-r6zKACMNhjPJMTl8KcFH4li//gkrXWfbD6feV8l6doRHlzljFWGJ2AP6iKaCJXyZmAUMOPtvbW7EXkbWO/pLEA==
4498
+
4499
+
p-map@^2.0.0:
4500
+
version "2.1.0"
4501
+
resolved "https://registry.yarnpkg.com/p-map/-/p-map-2.1.0.tgz#310928feef9c9ecc65b68b17693018a665cea175"
4502
+
integrity sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==
4503
+
4093
4504
p-queue@^2.4.2:
4094
4505
version "2.4.2"
4095
4506
resolved "https://registry.yarnpkg.com/p-queue/-/p-queue-2.4.2.tgz#03609826682b743be9a22dba25051bd46724fc34"
···
4100
4511
resolved "https://registry.yarnpkg.com/p-try/-/p-try-1.0.0.tgz#cbc79cdbaf8fd4228e13f621f2b1a237c1b207b3"
4101
4512
integrity sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=
4102
4513
4514
+
p-try@^2.0.0:
4515
+
version "2.2.0"
4516
+
resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
4517
+
integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==
4518
+
4103
4519
parse-glob@^3.0.4:
4104
4520
version "3.0.4"
4105
4521
resolved "https://registry.yarnpkg.com/parse-glob/-/parse-glob-3.0.4.tgz#b2c376cfb11f35513badd173ef0bb6e3a388391c"
···
4151
4567
version "1.0.1"
4152
4568
resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
4153
4569
integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18=
4570
+
4571
+
path-is-inside@^1.0.1, path-is-inside@^1.0.2:
4572
+
version "1.0.2"
4573
+
resolved "https://registry.yarnpkg.com/path-is-inside/-/path-is-inside-1.0.2.tgz#365417dede44430d1c11af61027facf074bdfc53"
4574
+
integrity sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM=
4154
4575
4155
4576
path-key@^2.0.0, path-key@^2.0.1:
4156
4577
version "2.0.1"
···
4216
4637
integrity sha1-9tXREJ4Z1j7fQo4L1X4Sd3YVM0s=
4217
4638
dependencies:
4218
4639
find-up "^2.1.0"
4640
+
4641
+
pkg-dir@^3.0.0:
4642
+
version "3.0.0"
4643
+
resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-3.0.0.tgz#2749020f239ed990881b1f71210d51eb6523bea3"
4644
+
integrity sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==
4645
+
dependencies:
4646
+
find-up "^3.0.0"
4647
+
4648
+
please-upgrade-node@^3.0.2, please-upgrade-node@^3.1.1:
4649
+
version "3.1.1"
4650
+
resolved "https://registry.yarnpkg.com/please-upgrade-node/-/please-upgrade-node-3.1.1.tgz#ed320051dfcc5024fae696712c8288993595e8ac"
4651
+
integrity sha512-KY1uHnQ2NlQHqIJQpnh/i54rKkuxCEBx+voJIS/Mvb+L2iYd2NMotwduhKTMjfC1uKoX3VXOxLjIYG66dfJTVQ==
4652
+
dependencies:
4653
+
semver-compare "^1.0.0"
4219
4654
4220
4655
pn@^1.1.0:
4221
4656
version "1.1.0"
···
4940
5375
kleur "^2.0.1"
4941
5376
sisteransi "^0.1.1"
4942
5377
5378
+
property-expr@^1.5.0:
5379
+
version "1.5.1"
5380
+
resolved "https://registry.yarnpkg.com/property-expr/-/property-expr-1.5.1.tgz#22e8706894a0c8e28d58735804f6ba3a3673314f"
5381
+
integrity sha512-CGuc0VUTGthpJXL36ydB6jnbyOf/rAHFvmVrJlH+Rg0DqqLFQGAP6hIaxD/G0OAmBJPhXDHuEJigrp0e0wFV6g==
5382
+
4943
5383
pseudomap@^1.0.2:
4944
5384
version "1.0.2"
4945
5385
resolved "https://registry.yarnpkg.com/pseudomap/-/pseudomap-1.0.2.tgz#f052a28da70e618917ef0a8ac34c1ae5a68286b3"
···
4962
5402
version "2.0.1"
4963
5403
resolved "https://registry.yarnpkg.com/pump/-/pump-2.0.1.tgz#12399add6e4cf7526d973cbc8b5ce2e2908b3909"
4964
5404
integrity sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==
5405
+
dependencies:
5406
+
end-of-stream "^1.1.0"
5407
+
once "^1.3.1"
5408
+
5409
+
pump@^3.0.0:
5410
+
version "3.0.0"
5411
+
resolved "https://registry.yarnpkg.com/pump/-/pump-3.0.0.tgz#b4a2116815bde2f4e1ea602354e8c75565107a64"
5412
+
integrity sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==
4965
5413
dependencies:
4966
5414
end-of-stream "^1.1.0"
4967
5415
once "^1.3.1"
···
5047
5495
normalize-package-data "^2.3.2"
5048
5496
path-type "^3.0.0"
5049
5497
5498
+
read-pkg@^4.0.1:
5499
+
version "4.0.1"
5500
+
resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-4.0.1.tgz#963625378f3e1c4d48c85872b5a6ec7d5d093237"
5501
+
integrity sha1-ljYlN48+HE1IyFhytabsfV0JMjc=
5502
+
dependencies:
5503
+
normalize-package-data "^2.3.2"
5504
+
parse-json "^4.0.0"
5505
+
pify "^3.0.0"
5506
+
5050
5507
readable-stream@^2.0.1, readable-stream@^2.0.6, readable-stream@^2.3.0, readable-stream@^2.3.5:
5051
5508
version "2.3.6"
5052
5509
resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.6.tgz#b11c27d88b8ff1fbe070643cf94b0c79ae1b0aaf"
···
5285
5742
dependencies:
5286
5743
path-parse "^1.0.6"
5287
5744
5745
+
restore-cursor@^2.0.0:
5746
+
version "2.0.0"
5747
+
resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-2.0.0.tgz#9f7ee287f82fd326d4fd162923d62129eee0dfaf"
5748
+
integrity sha1-n37ih/gv0ybU/RYpI9YhKe7g368=
5749
+
dependencies:
5750
+
onetime "^2.0.0"
5751
+
signal-exit "^3.0.2"
5752
+
5288
5753
ret@~0.1.10:
5289
5754
version "0.1.15"
5290
5755
resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc"
···
5300
5765
resolved "https://registry.yarnpkg.com/rgba-regex/-/rgba-regex-1.0.0.tgz#43374e2e2ca0968b0ef1523460b7d730ff22eeb3"
5301
5766
integrity sha1-QzdOLiyglosO8VI0YLfXMP8i7rM=
5302
5767
5303
-
rimraf@2, rimraf@^2.5.4, rimraf@^2.6.1, rimraf@^2.6.3:
5768
+
rimraf@2, rimraf@^2.2.8, rimraf@^2.5.4, rimraf@^2.6.1, rimraf@^2.6.3:
5304
5769
version "2.6.3"
5305
5770
resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.3.tgz#b2d104fe0d8fb27cf9e0a1cda8262dd3833c6cab"
5306
5771
integrity sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==
···
5459
5924
resolved "https://registry.yarnpkg.com/rsvp/-/rsvp-3.6.2.tgz#2e96491599a96cde1b515d5674a8f7a91452926a"
5460
5925
integrity sha512-OfWGQTb9vnwRjwtA2QwpG2ICclHC3pgXZO5xt8H2EfgDquO0qVdSb5T88L4qJVAEugbS56pAuV4XZM58UX8ulw==
5461
5926
5927
+
run-node@^1.0.0:
5928
+
version "1.0.0"
5929
+
resolved "https://registry.yarnpkg.com/run-node/-/run-node-1.0.0.tgz#46b50b946a2aa2d4947ae1d886e9856fd9cabe5e"
5930
+
integrity sha512-kc120TBlQ3mih1LSzdAJXo4xn/GWS2ec0l3S+syHDXP9uRr0JAT8Qd3mdMuyjqCzeZktgP3try92cEgf9Nks8A==
5931
+
5932
+
rxjs@^6.3.3:
5933
+
version "6.4.0"
5934
+
resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-6.4.0.tgz#f3bb0fe7bda7fb69deac0c16f17b50b0b8790504"
5935
+
integrity sha512-Z9Yfa11F6B9Sg/BK9MnqnQ+aQYicPLtilXBp2yUtDt2JRCE0h26d33EnfO3ZxoNxG0T92OUucP3Ct7cpfkdFfw==
5936
+
dependencies:
5937
+
tslib "^1.9.0"
5938
+
5462
5939
sade@^1.4.0:
5463
5940
version "1.4.2"
5464
5941
resolved "https://registry.yarnpkg.com/sade/-/sade-1.4.2.tgz#b1946ef9ec62450b74e17d9fec30156c94f193a6"
···
5503
5980
version "1.2.4"
5504
5981
resolved "https://registry.yarnpkg.com/sax/-/sax-1.2.4.tgz#2816234e2378bddc4e5354fab5caa895df7100d9"
5505
5982
integrity sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==
5983
+
5984
+
semver-compare@^1.0.0:
5985
+
version "1.0.0"
5986
+
resolved "https://registry.yarnpkg.com/semver-compare/-/semver-compare-1.0.0.tgz#0dee216a1c941ab37e9efb1788f6afc5ff5537fc"
5987
+
integrity sha1-De4hahyUGrN+nvsXiPavxf9VN/w=
5506
5988
5507
5989
"semver@2 || 3 || 4 || 5", semver@^5.3.0, semver@^5.4.1, semver@^5.5.0:
5508
5990
version "5.6.0"
···
5590
6072
once "^1.3.1"
5591
6073
simple-concat "^1.0.0"
5592
6074
6075
+
simple-git@^1.85.0:
6076
+
version "1.110.0"
6077
+
resolved "https://registry.yarnpkg.com/simple-git/-/simple-git-1.110.0.tgz#54eb179089d055a7783d32399246cebc9d9933e9"
6078
+
integrity sha512-UYY0rQkknk0P5eb+KW+03F4TevZ9ou0H+LoGaj7iiVgpnZH4wdj/HTViy/1tNNkmIPcmtxuBqXWiYt2YwlRKOQ==
6079
+
dependencies:
6080
+
debug "^4.0.1"
6081
+
5593
6082
simple-swizzle@^0.2.2:
5594
6083
version "0.2.2"
5595
6084
resolved "https://registry.yarnpkg.com/simple-swizzle/-/simple-swizzle-0.2.2.tgz#a4da6b635ffcccca33f70d17cb92592de95e557a"
···
5606
6095
version "1.0.0"
5607
6096
resolved "https://registry.yarnpkg.com/slash/-/slash-1.0.0.tgz#c41f2f6c39fc16d1cd17ad4b5d896114ae470d55"
5608
6097
integrity sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=
6098
+
6099
+
slash@^2.0.0:
6100
+
version "2.0.0"
6101
+
resolved "https://registry.yarnpkg.com/slash/-/slash-2.0.0.tgz#de552851a1759df3a8f206535442f5ec4ddeab44"
6102
+
integrity sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A==
6103
+
6104
+
slice-ansi@0.0.4:
6105
+
version "0.0.4"
6106
+
resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-0.0.4.tgz#edbf8903f66f7ce2f8eafd6ceed65e264c831b35"
6107
+
integrity sha1-7b+JA/ZvfOL46v1s7tZeJkyDGzU=
5609
6108
5610
6109
snapdragon-node@^2.0.1:
5611
6110
version "2.1.1"
···
5761
6260
resolved "https://registry.yarnpkg.com/stack-utils/-/stack-utils-1.0.2.tgz#33eba3897788558bebfc2db059dc158ec36cebb8"
5762
6261
integrity sha512-MTX+MeG5U994cazkjd/9KNAapsHnibjMLnfXodlkXw76JEea0UiNzrqidzo1emMwk7w5Qhc9jd4Bn9TBb1MFwA==
5763
6262
6263
+
staged-git-files@1.1.2:
6264
+
version "1.1.2"
6265
+
resolved "https://registry.yarnpkg.com/staged-git-files/-/staged-git-files-1.1.2.tgz#4326d33886dc9ecfa29a6193bf511ba90a46454b"
6266
+
integrity sha512-0Eyrk6uXW6tg9PYkhi/V/J4zHp33aNyi2hOCmhFLqLTIhbgqWn5jlSzI+IU0VqrZq6+DbHcabQl/WP6P3BG0QA==
6267
+
5764
6268
static-extend@^0.1.1:
5765
6269
version "0.1.2"
5766
6270
resolved "https://registry.yarnpkg.com/static-extend/-/static-extend-0.1.2.tgz#60809c39cbff55337226fd5e0b520f341f1fb5c6"
···
5778
6282
version "1.1.0"
5779
6283
resolved "https://registry.yarnpkg.com/strict-uri-encode/-/strict-uri-encode-1.1.0.tgz#279b225df1d582b1f54e65addd4352e18faa0713"
5780
6284
integrity sha1-J5siXfHVgrH1TmWt3UNS4Y+qBxM=
6285
+
6286
+
string-argv@^0.0.2:
6287
+
version "0.0.2"
6288
+
resolved "https://registry.yarnpkg.com/string-argv/-/string-argv-0.0.2.tgz#dac30408690c21f3c3630a3ff3a05877bdcbd736"
6289
+
integrity sha1-2sMECGkMIfPDYwo/86BYd73L1zY=
5781
6290
5782
6291
string-hash@^1.1.1:
5783
6292
version "1.1.3"
···
5824
6333
integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
5825
6334
dependencies:
5826
6335
safe-buffer "~5.1.0"
6336
+
6337
+
stringify-object@^3.2.2:
6338
+
version "3.3.0"
6339
+
resolved "https://registry.yarnpkg.com/stringify-object/-/stringify-object-3.3.0.tgz#703065aefca19300d3ce88af4f5b3956d7556629"
6340
+
integrity sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==
6341
+
dependencies:
6342
+
get-own-enumerable-property-symbols "^3.0.0"
6343
+
is-obj "^1.0.1"
6344
+
is-regexp "^1.0.0"
5827
6345
5828
6346
strip-ansi@^3.0.0, strip-ansi@^3.0.1:
5829
6347
version "3.0.1"
···
5941
6459
unquote "~1.1.1"
5942
6460
util.promisify "~1.0.0"
5943
6461
6462
+
symbol-observable@^1.1.0:
6463
+
version "1.2.0"
6464
+
resolved "https://registry.yarnpkg.com/symbol-observable/-/symbol-observable-1.2.0.tgz#c22688aed4eab3cdc2dfeacbb561660560a00804"
6465
+
integrity sha512-e900nM8RRtGhlV36KGEU9k65K3mPb1WV70OdjfxlG2EAuM1noi/E/BaW/uMhL7bPEssK8QV57vN3esixjUvcXQ==
6466
+
5944
6467
symbol-tree@^3.2.2:
5945
6468
version "3.2.2"
5946
6469
resolved "https://registry.yarnpkg.com/symbol-tree/-/symbol-tree-3.2.2.tgz#ae27db38f660a7ae2e1c3b7d1bc290819b8519e6"
5947
6470
integrity sha1-rifbOPZgp64uHDt9G8KQgZuFGeY=
6471
+
6472
+
synchronous-promise@^2.0.5:
6473
+
version "2.0.7"
6474
+
resolved "https://registry.yarnpkg.com/synchronous-promise/-/synchronous-promise-2.0.7.tgz#3574b3d2fae86b145356a4b89103e1577f646fe3"
6475
+
integrity sha512-16GbgwTmFMYFyQMLvtQjvNWh30dsFe1cAW5Fg1wm5+dg84L9Pe36mftsIRU95/W2YsISxsz/xq4VB23sqpgb/A==
5948
6476
5949
6477
tar-fs@^1.13.0:
5950
6478
version "1.16.3"
···
6073
6601
extend-shallow "^3.0.2"
6074
6602
regex-not "^1.0.2"
6075
6603
safe-regex "^1.1.0"
6604
+
6605
+
toposort@^2.0.2:
6606
+
version "2.0.2"
6607
+
resolved "https://registry.yarnpkg.com/toposort/-/toposort-2.0.2.tgz#ae21768175d1559d48bef35420b2f4962f09c330"
6608
+
integrity sha1-riF2gXXRVZ1IvvNUILL0li8JwzA=
6076
6609
6077
6610
tough-cookie@>=2.3.3:
6078
6611
version "3.0.0"
···
6348
6881
resolved "https://registry.yarnpkg.com/which-pm-runs/-/which-pm-runs-1.0.0.tgz#670b3afbc552e0b55df6b7780ca74615f23ad1cb"
6349
6882
integrity sha1-Zws6+8VS4LVd9rd4DKdGFfI60cs=
6350
6883
6351
-
which@1, which@^1.2.12, which@^1.2.9, which@^1.3.0:
6884
+
which@1, which@^1.2.10, which@^1.2.12, which@^1.2.9, which@^1.3.0:
6352
6885
version "1.3.1"
6353
6886
resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
6354
6887
integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
···
6379
6912
dependencies:
6380
6913
string-width "^1.0.1"
6381
6914
strip-ansi "^3.0.1"
6915
+
6916
+
wrap-ansi@^3.0.1:
6917
+
version "3.0.1"
6918
+
resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-3.0.1.tgz#288a04d87eda5c286e060dfe8f135ce8d007f8ba"
6919
+
integrity sha1-KIoE2H7aXChuBg3+jxNc6NAH+Lo=
6920
+
dependencies:
6921
+
string-width "^2.1.1"
6922
+
strip-ansi "^4.0.0"
6382
6923
6383
6924
wrappy@1:
6384
6925
version "1.0.2"
···
6450
6991
which-module "^2.0.0"
6451
6992
y18n "^3.2.1"
6452
6993
yargs-parser "^9.0.2"
6994
+
6995
+
yup@^0.26.10:
6996
+
version "0.26.10"
6997
+
resolved "https://registry.yarnpkg.com/yup/-/yup-0.26.10.tgz#3545839663289038faf25facfc07e11fd67c0cb1"
6998
+
integrity sha512-keuNEbNSnsOTOuGCt3UJW69jDE3O4P+UHAakO7vSeFMnjaitcmlbij/a3oNb9g1Y1KvSKH/7O1R2PQ4m4TRylw==
6999
+
dependencies:
7000
+
"@babel/runtime" "7.0.0"
7001
+
fn-name "~2.0.1"
7002
+
lodash "^4.17.10"
7003
+
property-expr "^1.5.0"
7004
+
synchronous-promise "^2.0.5"
7005
+
toposort "^2.0.2"