commit 21e02f2fbf87d9a6a2253630798cc0926f7e761c · kitten.sh/wonka

+930 -794

__tests__/wonka_test.re

···

       10
        
       

     

       11
        
           it("sends list items to a puller sink", () => {

     

       12
        
             let source = Wonka.fromList([10, 20, 30]);

     

       13
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       14
        
             let signals = [||];

     

       15
        
       

     

       16
       -
             source((.signal) => {

     

       17
        
               switch (signal) {

     

       18
       -
               | Start(x) => talkback := x;

     

       19
       -
               | Push(_) => ignore(Js.Array.push(signal, signals));

     

       20
        
               | End => ignore(Js.Array.push(signal, signals))

     

       21
       -
               };

     

       22
       -
             });

     

       23
        
       

     

       24
       -
             talkback^(.Pull);

     

       25
       -
             talkback^(.Pull);

     

       26
       -
             talkback^(.Pull);

     

       27
       -
             talkback^(.Pull);

     

       28
        
       

     

       29
       -
             expect(signals) == [| Push(10), Push(20), Push(30), End |];

     

       30
        
           });

     

       31
        
         });

     

       32
        
       

     
···

       35
        
           open! Expect.Operators;

     

       36
        
       

     

       37
        
           it("sends array items to a puller sink", () => {

     

       38
       -
             let source = Wonka.fromArray([| 10, 20, 30 |]);

     

       39
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       40
        
             let signals = ref([||]);

     

       41
        
       

     

       42
       -
             source((.signal) => {

     

       43
        
               switch (signal) {

     

       44
       -
               | Start(x) => {

     

       45
        
                 talkback := x;

     

       46
       -
                 x(.Pull);

     

       47
       -
               }

     

       48
       -
               | Push(_) => {

     

       49
        
                 signals := Array.append(signals^, [|signal|]);

     

       50
       -
                 talkback^(.Pull);

     

       0
        
       
     

       51
        
               }

     

       52
       -
               | End => signals := Array.append(signals^, [|signal|]);

     

       53
       -
               };

     

       54
       -
             });

     

       55
        
       

     

       56
       -
             expect(signals^) == [| Push(10), Push(20), Push(30), End |];

     

       57
        
           });

     

       58
        
       

     

       59
        
           it("does not blow up the stack when iterating something huge", () => {

     

       60
        
             let arr = Array.make(100000, 123);

     

       61
        
             let source = Wonka.fromArray(arr);

     

       62
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       63
        
             let values = [||];

     

       64
        
       

     

       65
       -
             source((.signal) => {

     

       66
        
               switch (signal) {

     

       67
       -
               | Start(x) => {

     

       68
        
                 talkback := x;

     

       69
       -
                 x(.Pull);

     

       70
       -
               }

     

       71
       -
               | Push(x) => {

     

       72
        
                 ignore(Js.Array.push(x, values));

     

       73
       -
                 talkback^(.Pull);

     

       0
        
       
     

       74
        
               }

     

       75
       -
               | End => ()

     

       76
       -
               };

     

       77
       -
             });

     

       78
        
       

     

       79
        
             expect(Array.length(values)) == Array.length(arr);

     

       80
        
           });

     
···

       86
        
       

     

       87
        
           it("sends a single item to a puller sink", () => {

     

       88
        
             let source = Wonka.fromValue(123);

     

       89
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       90
        
             let signals = [||];

     

       91
        
       

     

       92
       -
             source((.signal) => {

     

       93
        
               switch (signal) {

     

       94
       -
               | Start(x) => talkback := x;

     

       95
       -
               | Push(_) => ignore(Js.Array.push(signal, signals));

     

       96
        
               | End => ignore(Js.Array.push(signal, signals))

     

       97
       -
               };

     

       98
       -
             });

     

       99
        
       

     

       100
       -
             talkback^(.Pull);

     

       101
       -
             talkback^(.Pull);

     

       102
       -
             talkback^(.Pull); /* one extra to check whether no signal comes back after it has ended */

     

       103
        
       

     

       104
       -
             expect(signals) == [| Push(123), End |];

     

       105
        
           });

     

       106
        
         });

     

       107
        
       

     
···

       110
        
           open! Expect.Operators;

     

       111
        
       

     

       112
        
           it("ends immediately", () => {

     

       113
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       114
        
             let signals = [||];

     

       115
        
       

     

       116
       -
             Wonka.empty((.signal) => {

     

       117
        
               switch (signal) {

     

       118
       -
               | Start(x) => talkback := x;

     

       119
        
               | _ => ignore(Js.Array.push(signal, signals))

     

       120
       -
               };

     

       121
       -
             });

     

       122
        
       

     

       123
        
             let _signals = Array.copy(signals);

     

       124
        
       

     

       125
       -
             talkback^(.Pull);

     

       126
       -
             talkback^(.Pull);

     

       127
        
       

     

       128
       -
             expect((_signals, signals)) == ([| End |], [| End |]);

     

       129
        
           });

     

       130
        
         });

     

       131
        
       

     
···

       134
        
           open! Expect.Operators;

     

       135
        
       

     

       136
        
           it("does not end", () => {

     

       137
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       138
        
             let ended = ref(false);

     

       139
        
       

     

       140
       -
             Wonka.never((.signal) => {

     

       141
        
               switch (signal) {

     

       142
       -
               | Start(x) => talkback := x;

     

       143
        
               | End => ended := true

     

       144
        
               | _ => ()

     

       145
       -
               };

     

       146
       -
             });

     

       147
        
       

     

       148
       -
             talkback^(.Pull);

     

       149
       -
             talkback^(.Pull);

     

       150
        
       

     

       151
        
             expect(ended^) === false;

     

       152
        
           });

     
···

       160
        
           it("maps all emissions of a source", () => {

     

       161
        
             let num = ref(1);

     

       162
        
             let nums = [||];

     

       163
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       164
        
       

     

       165
       -
             Wonka.map((._) => {

     

       166
       -
               let res = num^;

     

       167
       -
               num := num^ + 1;

     

       168
       -
               res

     

       169
       -
             }, sink => {

     

       170
       -
               sink(.Start((.signal) => {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       171
        
                 switch (signal) {

     

       172
       -
                 | Pull => sink(.Push(1));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       173
        
                 | _ => ()

     

       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
       -
             });

     

       189
        
       

     

       190
       -
             expect(nums) |> toEqual([|1, 2, 3, 4|])

     

       191
        
           });

     

       192
        
       

     

       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
       -
           });

     

       201
        
       

     

       202
       -
           testPromise("ends itself and source when its talkback receives the End signal", () => {

     

       0
        
       
     

       203
        
             let end_: talkbackT = Close;

     

       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
       -
               })

     

       211
        
           });

     

       212
        
         });

     

       213
        
       

     
···

       217
        
           it("filters emissions according to a predicate", () => {

     

       218
        
             let i = ref(1);

     

       219
        
             let nums = [||];

     

       220
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       221
        
       

     

       222
       -
             Wonka.filter((.x) => x mod 2 === 0, sink => {

     

       223
       -
               sink(.Start((.signal) => {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       224
        
                 switch (signal) {

     

       225
       -
                 | Pull => {

     

       226
       -
                   let num = i^;

     

       227
       -
                   i := i^ + 1;

     

       228
       -
                   sink(.Push(num));

     

       229
       -
                 }

     

       0
        
       
     

       230
        
                 | _ => ()

     

       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
       -
             expect(nums) |> toEqual([|2, 4|])

     

       248
        
           });

     

       249
        
       

     

       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
       -
           });

     

       258
        
       

     

       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
       -
           });

     

       267
        
       

     

       268
       -
           testPromise("ends itself and source when its talkback receives the End signal", () => {

     

       0
        
       
     

       269
        
             let end_: talkbackT = Close;

     

       270
        
       

     

       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
       -
               })

     

       277
        
           });

     

       278
        
         });

     

       279
        
       

     
···

       281
        
           open Expect;

     

       282
        
       

     

       283
        
           it("folds emissions using an initial seed value", () => {

     

       284
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       285
        
             let num = ref(1);

     

       286
        
       

     

       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
       -
             })));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       301
        
       

     

       302
        
             let res = [||];

     

       303
        
       

     

       304
       -
             source((.signal) => {

     

       305
        
               switch (signal) {

     

       306
        
               | Start(x) => talkback := x

     

       307
        
               | _ => ignore(Js.Array.push(signal, res))

     

       308
        
               }

     

       309
       -
             });

     

       310
        
       

     

       311
       -
             talkback^(.Pull);

     

       312
       -
             talkback^(.Pull);

     

       313
       -
             talkback^(.Pull);

     

       314
       -
             talkback^(.Pull);

     

       315
       -
             expect(res) |> toEqual([| Push(1), Push(3), Push(6), End |]);

     

       316
        
           });

     

       317
        
       

     

       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
       -
           });

     

       326
        
       

     

       327
       -
           testPromise("ends itself and source when its talkback receives the End signal", () => {

     

       0
        
       
     

       328
        
             let end_: talkbackT = Close;

     

       329
        
       

     

       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
       -
               })

     

       336
        
           });

     

       337
        
         });

     

       338
        
       

     
···

       343
        
           it("merges different sources into a single one", () => {

     

       344
        
             let a = Wonka.fromList([1, 2, 3]);

     

       345
        
             let b = Wonka.fromList([4, 5, 6]);

     

       346
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       347
        
             let signals = [||];

     

       348
       -
             let source = Wonka.merge([| a, b |]);

     

       349
        
       

     

       350
       -
             source((.signal) => {

     

       351
        
               switch (signal) {

     

       352
       -
               | Start(x) => {

     

       353
        
                 talkback := x;

     

       354
       -
                 x(.Pull);

     

       355
       -
               }

     

       356
       -
               | Push(_) => {

     

       357
        
                 ignore(Js.Array.push(signal, signals));

     

       358
       -
                 talkback^(.Pull);

     

       0
        
       
     

       359
        
               }

     

       360
       -
               | End => ignore(Js.Array.push(signal, signals))

     

       361
       -
               };

     

       362
       -
             });

     

       363
        
       

     

       364
       -
             expect(signals) == [| Push(1), Push(2), Push(3), Push(4), Push(5), Push(6), End |];

     

       0
        
       
     

       365
        
           });

     

       366
        
       

     

       367
       -
           testPromise("follows the spec for listenables", () => {

     

       368
        
             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
       -
           });

     

       375
        
       

     

       376
       -
           testPromise("ends itself and source when its talkback receives the End signal", () => {

     

       0
        
       
     

       377
        
             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
       -
           });

     

       384
        
         });

     

       385
        
       

     

       386
        
         describe("concat", () => {

     
···

       390
        
           it("concatenates different sources into a single one", () => {

     

       391
        
             let a = Wonka.fromList([1, 2, 3]);

     

       392
        
             let b = Wonka.fromList([4, 5, 6]);

     

       393
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       394
        
             let signals = [||];

     

       395
       -
             let source = Wonka.concat([| a, b |]);

     

       396
        
       

     

       397
       -
             source((.signal) => {

     

       398
        
               switch (signal) {

     

       399
       -
               | Start(x) => {

     

       400
        
                 talkback := x;

     

       401
       -
                 x(.Pull);

     

       402
       -
               }

     

       403
       -
               | Push(_) => {

     

       404
        
                 ignore(Js.Array.push(signal, signals));

     

       405
       -
                 talkback^(.Pull);

     

       0
        
       
     

       406
        
               }

     

       407
       -
               | End => ignore(Js.Array.push(signal, signals))

     

       408
       -
               };

     

       409
       -
             });

     

       410
        
       

     

       411
       -
             expect(signals) == [| Push(1), Push(2), Push(3), Push(4), Push(5), Push(6), End |];

     

       0
        
       
     

       412
        
           });

     

       413
        
       

     

       414
       -
           testPromise("follows the spec for listenables", () => {

     

       415
        
             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
       -
           });

     

       422
        
       

     

       423
       -
           testPromise("ends itself and source when its talkback receives the End signal", () => {

     

       0
        
       
     

       424
        
             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
       -
           });

     

       431
        
         });

     

       432
        
       

     

       433
        
         describe("share", () => {

     

       434
        
           open Expect;

     

       435
        
       

     

       436
        
           it("shares an underlying source with all sinks", () => {

     

       437
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       438
       -
             let aborterTb = ref((._: Wonka_types.talkbackT) => ());

     

       439
        
             let num = ref(1);

     

       440
        
             let nums = [||];

     

       441
        
       

     

       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
       -
             });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       458
        
       

     

       459
       -
             source((.signal) => {

     

       460
        
               switch (signal) {

     

       461
        
               | Start(x) => talkback := x

     

       462
        
               | _ => ignore(Js.Array.push(signal, nums))

     

       463
        
               }

     

       464
       -
             });

     

       465
        
       

     

       466
       -
             source((.signal) => {

     

       467
        
               switch (signal) {

     

       468
        
               | Start(_) => ()

     

       469
        
               | _ => ignore(Js.Array.push(signal, nums))

     

       470
        
               }

     

       471
       -
             });

     

       472
        
       

     

       473
       -
             source((.signal) => {

     

       474
        
               switch (signal) {

     

       475
        
               | Start(tb) => aborterTb := tb

     

       476
       -
               | _ => {

     

       477
        
                 ignore(Js.Array.push(signal, nums));

     

       478
       -
                 aborterTb^(.Close);

     

       479
        
               }

     

       480
       -
               }

     

       481
       -
             });

     

       482
        
       

     

       483
       -
             talkback^(.Pull);

     

       484
        
             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 |]));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       489
        
           });

     

       490
        
       

     

       491
       -
           testPromise("follows the spec for listenables", () => {

     

       492
        
             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
       -
           });

     

       499
        
       

     

       500
       -
           testPromise("ends itself and source when its talkback receives the End signal", () => {

     

       0
        
       
     

       501
        
             let end_: talkbackT = Close;

     

       502
        
       

     

       503
        
             Wonka_thelpers.testTalkbackEnd(Wonka.share)

     

       504
       -
               |> Js.Promise.then_(x => {

     

       505
       -
                 expect(x)

     

       506
       -
                   |> toEqual(([| end_ |], [| Push(1) |]))

     

       507
       -
                   |> Js.Promise.resolve

     

       508
       -
               })

     

       509
        
           });

     

       510
        
         });

     

       511
        
       

     
···

       513
        
           open Expect;

     

       514
        
       

     

       515
        
           it("combines the latest values of two sources", () => {

     

       516
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       517
        
       

     

       518
        
             let makeSource = (factor: int) => {

     

       519
        
               let num = ref(1);

     

       520
        
       

     

       521
        
               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
       -
               }

     

       0
        
       
     

       0
        
       
     

       537
        
             };

     

       538
        
       

     

       539
        
             let sourceA = makeSource(1);

     
···

       541
        
             let source = Wonka.combine(sourceA, sourceB);

     

       542
        
             let res = [||];

     

       543
        
       

     

       544
       -
             source((.signal) => {

     

       545
        
               switch (signal) {

     

       546
        
               | Start(x) => talkback := x

     

       547
        
               | _ => ignore(Js.Array.push(signal, res))

     

       548
        
               }

     

       549
       -
             });

     

       550
        
       

     

       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 |]);

     

       0
        
       
     

       556
        
           });

     

       557
        
       

     

       558
       -
           testPromise("follows the spec for listenables", () => {

     

       559
        
             Wonka_thelpers.testWithListenable(source => {

     

       560
        
               let shared = Wonka.share(source);

     

       561
       -
               Wonka.combine(shared, shared)

     

       562
        
             })

     

       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
       -
           });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       569
        
       

     

       570
       -
           testPromise("ends itself and source when its talkback receives the End signal", () => {

     

       0
        
       
     

       571
        
             let end_: talkbackT = Close;

     

       572
        
       

     

       573
        
             Wonka_thelpers.testTalkbackEnd(source => {

     

       574
        
               let shared = Wonka.share(source);

     

       575
       -
               Wonka.combine(shared, shared)

     

       576
        
             })

     

       577
       -
               |> Js.Promise.then_(x => {

     

       578
       -
                 expect(x)

     

       579
       -
                   |> toEqual(([| end_ |], [| Push((1, 1)) |]))

     

       580
       -
                   |> Js.Promise.resolve

     

       581
       -
               })

     

       582
        
           });

     

       583
        
         });

     

       584
        
       

     
···

       586
        
           open Expect;

     

       587
        
       

     

       588
        
           it("only lets a maximum number of values through", () => {

     

       589
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       590
        
             let num = ref(1);

     

       591
        
       

     

       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
       -
             })));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       602
        
       

     

       603
        
             let res = [||];

     

       604
        
       

     

       605
       -
             source((.signal) => {

     

       606
        
               switch (signal) {

     

       607
        
               | Start(x) => talkback := x

     

       608
        
               | _ => ignore(Js.Array.push(signal, res))

     

       609
        
               }

     

       610
       -
             });

     

       611
        
       

     

       612
       -
             talkback^(.Pull);

     

       613
       -
             talkback^(.Pull);

     

       614
       -
             talkback^(.Pull);

     

       615
       -
             talkback^(.Pull);

     

       616
       -
             expect(res) |> toEqual([| Push(1), Push(2), End |]);

     

       617
        
           });

     

       618
        
       

     

       619
       -
           it("accepts the end of the source when max number of emissions is not reached", () => {

     

       620
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       0
        
       
     

       0
        
       
     

       621
        
             let num = ref(1);

     

       622
        
       

     

       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
       -
             })));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       637
        
       

     

       638
        
             let res = [||];

     

       639
        
       

     

       640
       -
             source((.signal) => {

     

       641
        
               switch (signal) {

     

       642
        
               | Start(x) => talkback := x

     

       643
        
               | _ => ignore(Js.Array.push(signal, res))

     

       644
        
               }

     

       645
       -
             });

     

       646
        
       

     

       647
       -
             talkback^(.Pull);

     

       648
       -
             talkback^(.Pull);

     

       649
       -
             talkback^(.Pull);

     

       650
       -
             expect(res) |> toEqual([| Push(1), End |]);

     

       651
        
           });

     

       652
        
       

     

       653
       -
           testPromise("follows the spec for listenables", () => {

     

       654
        
             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
       -
           });

     

       661
        
       

     

       662
        
           testPromise("follows the spec for listenables when ending the source", () => {

     

       663
        
             let end_: talkbackT = Close;

     

       664
        
       

     

       665
        
             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
       -
               })

     

       671
        
           });

     

       672
        
       

     

       673
       -
           testPromise("ends itself and source when its talkback receives the End signal", () => {

     

       0
        
       
     

       674
        
             let end_: talkbackT = Close;

     

       675
        
       

     

       676
        
             Wonka_thelpers.testTalkbackEnd(Wonka.take(10))

     

       677
       -
               |> Js.Promise.then_(x => {

     

       678
       -
                 expect(x)

     

       679
       -
                   |> toEqual(([| end_ |], [| Push(1) |]))

     

       680
       -
                   |> Js.Promise.resolve

     

       681
       -
               })

     

       682
        
           });

     

       683
        
         });

     

       684
        
       

     
···

       686
        
           open Expect;

     

       687
        
       

     

       688
        
           it("only lets the last n values through on an entirely new source", () => {

     

       689
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       690
        
             let num = ref(1);

     

       691
        
       

     

       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
       -
             })));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       703
        
       

     

       704
        
             let res = [||];

     

       705
        
       

     

       706
       -
             source((.signal) => {

     

       707
        
               switch (signal) {

     

       708
        
               | Start(x) => talkback := x

     

       709
        
               | _ => ignore(Js.Array.push(signal, res))

     

       710
        
               }

     

       711
       -
             });

     

       712
        
       

     

       713
       -
             talkback^(.Pull);

     

       714
       -
             talkback^(.Pull);

     

       715
       -
             talkback^(.Pull);

     

       716
       -
             expect(res) |> toEqual([| Push(3), Push(4), End |]);

     

       717
        
           });

     

       718
        
       

     

       719
       -
           testPromise("follows the spec for listenables", () => {

     

       720
        
             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
       -
           });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       727
        
       

     

       728
       -
           testPromise("ends itself and source when its talkback receives the End signal", () => {

     

       0
        
       
     

       729
        
             Wonka_thelpers.testTalkbackEnd(Wonka.takeLast(10))

     

       730
       -
               |> Js.Promise.then_(x => {

     

       731
       -
                 expect(x)

     

       732
       -
                   |> toEqual(([| Pull, Pull |], [| |]))

     

       733
       -
                   |> Js.Promise.resolve

     

       734
       -
               })

     

       735
       -
           });

     

       736
        
         });

     

       737
        
       

     

       738
        
         describe("takeWhile", () => {

     

       739
        
           open Expect;

     

       740
        
       

     

       741
        
           it("only lets the last n values through on an entirely new source", () => {

     

       742
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       743
        
             let num = ref(1);

     

       744
        
       

     

       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
       -
             })));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       755
        
       

     

       756
        
             let res = [||];

     

       757
        
       

     

       758
       -
             source((.signal) => {

     

       759
        
               switch (signal) {

     

       760
        
               | Start(x) => talkback := x

     

       761
        
               | _ => ignore(Js.Array.push(signal, res))

     

       762
        
               }

     

       763
       -
             });

     

       764
        
       

     

       765
       -
             talkback^(.Pull);

     

       766
       -
             talkback^(.Pull);

     

       767
       -
             talkback^(.Pull);

     

       768
       -
             talkback^(.Pull);

     

       769
        
       

     

       770
       -
             expect(res) |> toEqual([| Push(1), Push(2), End |]);

     

       771
        
           });

     

       772
        
       

     

       773
       -
           it("accepts the end of the source when max number of emissions is not reached", () => {

     

       774
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       0
        
       
     

       0
        
       
     

       775
        
             let num = ref(1);

     

       776
        
       

     

       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
       -
             })));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       791
        
       

     

       792
        
             let res = [||];

     

       793
        
       

     

       794
       -
             source((.signal) => {

     

       795
        
               switch (signal) {

     

       796
        
               | Start(x) => talkback := x

     

       797
        
               | _ => ignore(Js.Array.push(signal, res))

     

       798
        
               }

     

       799
       -
             });

     

       800
        
       

     

       801
       -
             talkback^(.Pull);

     

       802
       -
             talkback^(.Pull);

     

       803
       -
             talkback^(.Pull);

     

       804
        
       

     

       805
       -
             expect(res) |> toEqual([| Push(1), End |]);

     

       806
        
           });

     

       807
        
       

     

       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
       -
           });

     

       816
        
       

     

       817
        
           testPromise("follows the spec for listenables when ending the source", () => {

     

       818
        
             let end_: talkbackT = Close;

     

       819
        
       

     

       820
       -
             Wonka_thelpers.testWithListenable(Wonka.takeWhile((._) => false))

     

       821
       -
               |> Js.Promise.then_(x => {

     

       822
       -
                 expect(x)

     

       823
       -
                   |> toEqual(([| end_ |], [| End |]))

     

       824
       -
                   |> Js.Promise.resolve

     

       825
       -
               })

     

       826
        
           });

     

       827
        
       

     

       828
       -
           testPromise("ends itself and source when its talkback receives the End signal", () => {

     

       0
        
       
     

       829
        
             let end_: talkbackT = Close;

     

       830
        
       

     

       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
       -
               })

     

       837
        
           });

     

       838
        
         });

     

       839
        
       

     
···

       841
        
           open Expect;

     

       842
        
       

     

       843
        
           it("only lets the last n values through on an entirely new source", () => {

     

       844
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       845
        
             let notify = ref((_: Wonka_types.talkbackT) => ());

     

       846
        
             let num = ref(1);

     

       847
        
       

     

       848
        
             let notifier = sink => {

     

       849
       -
               notify := signal => switch (signal) {

     

       850
       -
               | Pull => sink(.Push(0));

     

       851
       -
               | _ => ()

     

       852
       -
               };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       853
        
       

     

       854
       -
               sink(.Start(Wonka_helpers.talkbackPlaceholder));

     

       855
        
             };

     

       856
        
       

     

       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
       -
             })));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       868
        
       

     

       869
        
             let res = [||];

     

       870
        
       

     

       871
       -
             source((.signal) => {

     

       872
        
               switch (signal) {

     

       873
        
               | Start(x) => talkback := x

     

       874
        
               | _ => ignore(Js.Array.push(signal, res))

     

       875
        
               }

     

       876
       -
             });

     

       877
        
       

     

       878
       -
             talkback^(.Pull);

     

       879
       -
             talkback^(.Pull);

     

       880
       -
             talkback^(.Pull);

     

       881
       -
             talkback^(.Pull);

     

       882
        
       

     

       883
       -
             expect(res) |> toEqual([| Push(1), Push(2), End |]);

     

       884
        
           });

     

       885
        
       

     

       886
       -
           it("accepts the end of the source when max number of emissions is not reached", () => {

     

       887
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       0
        
       
     

       0
        
       
     

       888
        
             let num = ref(1);

     

       889
       -
             let notifier = sink => sink(.Start(Wonka_helpers.talkbackPlaceholder));

     

       0
        
       
     

       890
        
       

     

       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
       -
             })));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       905
        
       

     

       906
        
             let res = [||];

     

       907
        
       

     

       908
       -
             source((.signal) => {

     

       909
        
               switch (signal) {

     

       910
        
               | Start(x) => talkback := x

     

       911
        
               | _ => ignore(Js.Array.push(signal, res))

     

       912
        
               }

     

       913
       -
             });

     

       914
        
       

     

       915
       -
             talkback^(.Pull);

     

       916
       -
             talkback^(.Pull);

     

       917
       -
             talkback^(.Pull);

     

       918
       -
             talkback^(.Pull);

     

       919
        
       

     

       920
       -
             expect(res) |> toEqual([| Push(1), Push(2), End |]);

     

       921
        
           });

     

       922
        
       

     

       923
       -
           testPromise("follows the spec for listenables", () => {

     

       924
        
             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
       -
           });

     

       931
        
       

     

       932
        
           testPromise("follows the spec for listenables when ending the source", () => {

     

       933
        
             let end_: talkbackT = Close;

     

       934
        
       

     

       935
        
             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
       -
               })

     

       941
        
           });

     

       942
        
       

     

       943
       -
           testPromise("ends itself and source when its talkback receives the End signal", () => {

     

       0
        
       
     

       944
        
             let end_: talkbackT = Close;

     

       945
        
       

     

       946
        
             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
       -
               })

     

       952
        
           });

     

       953
        
         });

     

       954
        
       

     

       955
        
         describe("skip", () => {

     

       956
        
           open Expect;

     

       957
        
       

     

       958
       -
           it("only lets values through after a number of values have been filtered out", () => {

     

       959
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       0
        
       
     

       0
        
       
     

       960
        
             let num = ref(1);

     

       961
        
       

     

       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
       -
             })));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       973
        
       

     

       974
        
             let res = [||];

     

       975
        
       

     

       976
       -
             source((.signal) => {

     

       977
        
               switch (signal) {

     

       978
        
               | Start(x) => talkback := x

     

       979
        
               | _ => ignore(Js.Array.push(signal, res))

     

       980
        
               }

     

       981
       -
             });

     

       982
        
       

     

       983
       -
             talkback^(.Pull);

     

       984
       -
             talkback^(.Pull);

     

       985
       -
             talkback^(.Pull);

     

       986
       -
             expect(res) |> toEqual([| Push(3), Push(4), End |]);

     

       987
        
           });

     

       988
        
       

     

       989
       -
           testPromise("follows the spec for listenables", () => {

     

       990
        
             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
       -
           });

     

       997
        
       

     

       998
       -
           testPromise("follows the spec for listenables when skipping the source", () => {

     

       0
        
       
     

       999
        
             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
       -
           });

     

       1006
        
       

     

       1007
       -
           testPromise("ends itself and source when its talkback receives the End signal", () => {

     

       0
        
       
     

       1008
        
             let end_: talkbackT = Close;

     

       1009
        
       

     

       1010
        
             Wonka_thelpers.testTalkbackEnd(Wonka.skip(10))

     

       1011
       -
               |> Js.Promise.then_(x => {

     

       1012
       -
                 expect(x)

     

       1013
       -
                   |> toEqual(([| Pull, end_ |], [| |]))

     

       1014
       -
                   |> Js.Promise.resolve

     

       1015
       -
               })

     

       1016
        
           });

     

       1017
        
         });

     

       1018
        
       

     

       1019
        
         describe("skipWhile", () => {

     

       1020
        
           open Expect;

     

       1021
        
       

     

       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);

     

       0
        
       
     

       0
        
       
     

       1025
        
       

     

       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
       -
             })));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1037
        
       

     

       1038
       -
             let res = [||];

     

       1039
        
       

     

       1040
       -
             source((.signal) => {

     

       1041
       -
               switch (signal) {

     

       1042
       -
               | Start(x) => talkback := x

     

       1043
       -
               | _ => ignore(Js.Array.push(signal, res))

     

       1044
       -
               }

     

       1045
       -
             });

     

       1046
        
       

     

       1047
       -
             talkback^(.Pull);

     

       1048
       -
             talkback^(.Pull);

     

       1049
       -
             talkback^(.Pull);

     

       1050
       -
             expect(res) |> toEqual([| Push(3), Push(4), End |]);

     

       1051
       -
           });

     

       0
        
       
     

       1052
        
       

     

       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
       -
           });

     

       1061
        
       

     

       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
       -
           });

     

       0
        
       
     

       1070
        
       

     

       1071
       -
           testPromise("ends itself and source when its talkback receives the End signal", () => {

     

       0
        
       
     

       1072
        
             let end_: talkbackT = Close;

     

       1073
        
       

     

       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
       -
               })

     

       1080
        
           });

     

       1081
        
         });

     

       1082
        
       

     
···

       1084
        
           open Expect;

     

       1085
        
       

     

       1086
        
           it("only lets values through after the notifier emits a value", () => {

     

       1087
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       1088
        
             let notify = ref((_: Wonka_types.talkbackT) => ());

     

       1089
        
             let num = ref(1);

     

       1090
        
       

     

       1091
        
             let notifier = sink => {

     

       1092
       -
               notify := signal => switch (signal) {

     

       1093
       -
               | Pull => sink(.Push(0));

     

       1094
       -
               | _ => ()

     

       1095
       -
               };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1096
        
       

     

       1097
       -
               sink(.Start(Wonka_helpers.talkbackPlaceholder));

     

       1098
        
             };

     

       1099
        
       

     

       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
       -
             })));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1112
        
       

     

       1113
        
             let res = [||];

     

       1114
        
       

     

       1115
       -
             source((.signal) => {

     

       1116
        
               switch (signal) {

     

       1117
        
               | Start(x) => talkback := x

     

       1118
        
               | _ => ignore(Js.Array.push(signal, res))

     

       1119
        
               }

     

       1120
       -
             });

     

       1121
        
       

     

       1122
       -
             talkback^(.Pull);

     

       1123
       -
             talkback^(.Pull);

     

       1124
       -
             talkback^(.Pull);

     

       1125
       -
             talkback^(.Pull);

     

       1126
        
       

     

       1127
       -
             expect(res) |> toEqual([| Push(3), Push(4), End |]);

     

       1128
        
           });

     

       1129
        
       

     

       1130
       -
           it("accepts the end of the source when max number of emissions is not reached", () => {

     

       1131
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       0
        
       
     

       0
        
       
     

       1132
        
             let num = ref(1);

     

       1133
       -
             let notifier = sink => sink(.Start(Wonka_helpers.talkbackPlaceholder));

     

       0
        
       
     

       1134
        
       

     

       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
       -
             })));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1149
        
       

     

       1150
        
             let res = [||];

     

       1151
        
       

     

       1152
       -
             source((.signal) => {

     

       1153
        
               switch (signal) {

     

       1154
        
               | Start(x) => talkback := x

     

       1155
        
               | _ => ignore(Js.Array.push(signal, res))

     

       1156
        
               }

     

       1157
       -
             });

     

       1158
        
       

     

       1159
       -
             talkback^(.Pull);

     

       1160
       -
             talkback^(.Pull);

     

       1161
       -
             talkback^(.Pull);

     

       1162
        
       

     

       1163
       -
             expect(res) |> toEqual([| End |]);

     

       1164
        
           });

     

       1165
        
       

     

       1166
       -
           testPromise("follows the spec for listenables", () => {

     

       1167
        
             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
       -
           });

     

       1174
        
       

     

       1175
       -
           testPromise("follows the spec for listenables when skipping the source", () => {

     

       0
        
       
     

       1176
        
             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
       -
           });

     

       1183
        
       

     

       1184
       -
           testPromise("ends itself and source when its talkback receives the End signal", () => {

     

       0
        
       
     

       1185
        
             let end_: talkbackT = Close;

     

       1186
        
       

     

       1187
        
             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
       -
               })

     

       1193
        
           });

     

       1194
        
         });

     

       1195
        
       

     

       1196
       -
         describe("flatten", () => {

     

       1197
       -
           open Expect;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1198
        
       

     

       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;

     

       1203
        
       

     

       1204
       -
             let res = [||];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1205
        
       

     

       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
       -
         });

     

       1221
        
       

     

       1222
        
         describe("switchMap", () => {

     

       1223
        
           afterEach(() => Jest.useRealTimers());

     

       1224
       -
       

     

       1225
        
           open Expect;

     

       1226
        
           open! Expect.Operators;

     

       1227
        
       

     
···

       1230
        
       

     

       1231
        
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       1232
        
             let signals = [||];

     

       1233
       -
             let source = Wonka.switchMap((.x) => Wonka.fromList([x * x]), a);

     

       1234
        
       

     

       1235
       -
             source((.signal) =>

     

       1236
        
               switch (signal) {

     

       1237
        
               | Start(x) =>

     

       1238
        
                 talkback := x;

     

       1239
       -
                 x(.Pull);

     

       1240
        
               | Push(_) =>

     

       1241
        
                 ignore(Js.Array.push(signal, signals));

     

       1242
       -
                 talkback^(.Pull);

     

       1243
        
               | End => ignore(Js.Array.push(signal, signals))

     

       1244
        
               }

     

       1245
        
             );

     
···

       1252
        
       

     

       1253
        
             let a = Wonka.interval(100);

     

       1254
        
       

     

       1255
       -
             let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       1256
        
             let signals = [||];

     

       1257
        
             let source =

     

       1258
       -
               Wonka.switchMap((._) => Wonka.interval(25), a) |> Wonka.take(5);

     

       1259
        
       

     

       1260
       -
             source((.signal) =>

     

       1261
        
               switch (signal) {

     

       1262
        
               | Start(x) =>

     

       1263
        
                 talkback := x;

     

       1264
       -
                 x(.Pull);

     

       1265
        
               | Push(_) =>

     

       1266
        
                 ignore(Js.Array.push(signal, signals));

     

       1267
       -
                 talkback^(.Pull);

     

       1268
        
               | End => ignore(Js.Array.push(signal, signals))

     

       1269
        
               }

     

       1270
        
             );

     
···

       1277
        
       

     

       1278
        
           testPromise("follows the spec for listenables", () =>

     

       1279
        
             Wonka_thelpers.testWithListenable(source =>

     

       1280
       -
               Wonka.switchMap((.x) => x, Wonka.fromList([source]))

     

       1281
        
             )

     

       1282
        
             |> Js.Promise.then_(x =>

     

       1283
        
                  expect(x)

     
···

       1289
        
           testPromise(

     

       1290
        
             "ends itself and source when its talkback receives the End signal", () =>

     

       1291
        
             Wonka_thelpers.testTalkbackEnd(source =>

     

       1292
       -
               Wonka.switchMap((.x) => x, Wonka.fromList([source]))

     

       1293
        
             )

     

       1294
        
             |> Js.Promise.then_(x =>

     

       1295
        
                  expect(x)

     
···

       1301
        
       });

     

       1302
        
       

     

       1303
        
       describe("sink factories", () => {

     

       1304
       -
         describe("forEach", () => {

     

       1305
       -
           open Expect;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1306
        
       

     

       1307
       -
           it("calls a function for each emission of the passed source", () => {

     

       1308
       -
             let i = ref(0);

     

       1309
       -
             let nums = [||];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1310
        
       

     

       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
       -
             };

     

       1324
        
       

     

       1325
       -
             Wonka.forEach((.x) => ignore(Js.Array.push(x, nums)), source);

     

       1326
       -
             expect(nums) |> toEqual([| 0, 1, 2, 3 |])

     

       1327
       -
           });

     

       1328
       -
         });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1329
        
       

     

       1330
       -
         describe("subscribe", () => {

     

       1331
       -
           open Expect;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1332
        
       

     

       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
       -
               };

     

       1344
        
       

     

       1345
       -
               sink(.Start(Wonka_helpers.talkbackPlaceholder));

     

       1346
       -
             };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1347
        
       

     

       1348
       -
             let { unsubscribe } = Wonka.subscribe((.x) => ignore(Js.Array.push(x, nums)), source);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1349
        
       

     

       1350
       -
             push^();

     

       1351
       -
             push^();

     

       1352
       -
             unsubscribe();

     

       1353
       -
             push^();

     

       1354
       -
             push^();

     

       1355
       -
       

     

       1356
       -
             expect(nums) |> toEqual([| 0, 1 |])

     

       1357
       -
           });

     

       1358
       -
         });

     

       1359
        
       });

     

       1360
        
       

     

       1361
       -
       describe("chains (integration)", () => {

     

       1362
       -
         open Expect;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1363
        
       

     

       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

     

       1370
        
             |> Wonka.fromArray

     

       1371
       -
             |> Wonka.map((.x) => string_of_int(x))

     

       1372
       -
             |> Wonka.forEach((.x) => ignore(Js.Array.push(x, actual)));

     

       1373
        
       

     

       1374
       -
           expect(output) |> toEqual(output)

     

       1375
       -
         });

     

       1376
       -
       });

     

       0
        
       
     

       1377
        
       

     

       1378
        
       describe("subject", () => {

     

       1379
        
         open Expect;

     
···

       1384
        
       

     

       1385
        
           let subject = Wonka.makeSubject();

     

       1386
        
       

     

       1387
       -
           subject.source((.signal) =>

     

       1388
        
             switch (signal) {

     

       1389
        
             | Start(_) => ignore()

     

       1390
        
             | Push(_) => ignore(Js.Array.push(signal, signals))

     
···

       1402
        
         });

     

       1403
        
       

     

       1404
        
         it("handles multiple sinks", () => {

     

       1405
       -
           let talkback = ref((._: Wonka_types.talkbackT) => ());

     

       1406
        
           let signalsOne = [||];

     

       1407
        
           let signalsTwo = [||];

     

       1408
        
       

     

       1409
        
           let subject = Wonka.makeSubject();

     

       1410
        
       

     

       1411
       -
           subject.source((.signal) =>

     

       1412
        
             switch (signal) {

     

       1413
        
             | Start(x) => talkback := x

     

       1414
        
             | Push(_) => ignore(Js.Array.push(signal, signalsOne))

     
···

       1416
        
             }

     

       1417
        
           );

     

       1418
        
       

     

       1419
       -
           subject.source((.signal) =>

     

       1420
        
             switch (signal) {

     

       1421
        
             | Start(_) => ignore()

     

       1422
        
             | Push(_) => ignore(Js.Array.push(signal, signalsTwo))

     
···

       1428
        
           subject.next(20);

     

       1429
        
           subject.next(30);

     

       1430
        
       

     

       1431
       -
           talkback^(.Close);

     

       1432
        
       

     

       1433
        
           subject.next(40);

     

       1434
        
           subject.next(50);

     
···

       1443
        
         });

     

       1444
        
       

     

       1445
        
         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) => ());

     

       1448
        
           let signalsOne = [||];

     

       1449
        
           let signalsTwo = [||];

     

       1450
        
       

     
···

       1453
        
           subject.next(10);

     

       1454
        
           subject.next(20);

     

       1455
        
       

     

       1456
       -
           subject.source((.signal) =>

     

       1457
        
             switch (signal) {

     

       1458
        
             | Start(x) => talkbackOne := x

     

       1459
        
             | Push(_) => ignore(Js.Array.push(signal, signalsOne))

     
···

       1463
        
       

     

       1464
        
           subject.next(30);

     

       1465
        
       

     

       1466
       -
           subject.source((.signal) =>

     

       1467
        
             switch (signal) {

     

       1468
        
             | Start(x) => talkbackTwo := x

     

       1469
        
             | Push(_) => ignore(Js.Array.push(signal, signalsTwo))

     
···

       1474
        
           subject.next(40);

     

       1475
        
           subject.next(50);

     

       1476
        
       

     

       1477
       -
           talkbackTwo^(.Close);

     

       1478
        
       

     

       1479
        
           subject.next(60);

     

       1480
        
       

     

       1481
       -
           talkbackOne^(.Close);

     

       1482
        
       

     

       1483
        
           subject.next(70);

     

       1484
        
           subject.complete();

···

       10
        
       

     

       11
        
           it("sends list items to a puller sink", () => {

     

       12
        
             let source = Wonka.fromList([10, 20, 30]);

     

       13
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       14
        
             let signals = [||];

     

       15
        
       

     

       16
       +
             source((. signal) =>

     

       17
        
               switch (signal) {

     

       18
       +
               | Start(x) => talkback := x

     

       19
       +
               | Push(_) => ignore(Js.Array.push(signal, signals))

     

       20
        
               | End => ignore(Js.Array.push(signal, signals))

     

       21
       +
               }

     

       22
       +
             );

     

       23
        
       

     

       24
       +
             talkback^(. Pull);

     

       25
       +
             talkback^(. Pull);

     

       26
       +
             talkback^(. Pull);

     

       27
       +
             talkback^(. Pull);

     

       28
        
       

     

       29
       +
             expect(signals) == [|Push(10), Push(20), Push(30), End|];

     

       30
        
           });

     

       31
        
         });

     

       32
        
       

     
···

       35
        
           open! Expect.Operators;

     

       36
        
       

     

       37
        
           it("sends array items to a puller sink", () => {

     

       38
       +
             let source = Wonka.fromArray([|10, 20, 30|]);

     

       39
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       40
        
             let signals = ref([||]);

     

       41
        
       

     

       42
       +
             source((. signal) =>

     

       43
        
               switch (signal) {

     

       44
       +
               | Start(x) =>

     

       45
        
                 talkback := x;

     

       46
       +
                 x(. Pull);

     

       47
       +
               | Push(_) =>

     

       0
        
       
     

       48
        
                 signals := Array.append(signals^, [|signal|]);

     

       49
       +
                 talkback^(. Pull);

     

       50
       +
               | End => signals := Array.append(signals^, [|signal|])

     

       51
        
               }

     

       52
       +
             );

     

       0
        
       
     

       0
        
       
     

       53
        
       

     

       54
       +
             expect(signals^) == [|Push(10), Push(20), Push(30), End|];

     

       55
        
           });

     

       56
        
       

     

       57
        
           it("does not blow up the stack when iterating something huge", () => {

     

       58
        
             let arr = Array.make(100000, 123);

     

       59
        
             let source = Wonka.fromArray(arr);

     

       60
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       61
        
             let values = [||];

     

       62
        
       

     

       63
       +
             source((. signal) =>

     

       64
        
               switch (signal) {

     

       65
       +
               | Start(x) =>

     

       66
        
                 talkback := x;

     

       67
       +
                 x(. Pull);

     

       68
       +
               | Push(x) =>

     

       0
        
       
     

       69
        
                 ignore(Js.Array.push(x, values));

     

       70
       +
                 talkback^(. Pull);

     

       71
       +
               | End => ()

     

       72
        
               }

     

       73
       +
             );

     

       0
        
       
     

       0
        
       
     

       74
        
       

     

       75
        
             expect(Array.length(values)) == Array.length(arr);

     

       76
        
           });

     
···

       82
        
       

     

       83
        
           it("sends a single item to a puller sink", () => {

     

       84
        
             let source = Wonka.fromValue(123);

     

       85
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       86
        
             let signals = [||];

     

       87
        
       

     

       88
       +
             source((. signal) =>

     

       89
        
               switch (signal) {

     

       90
       +
               | Start(x) => talkback := x

     

       91
       +
               | Push(_) => ignore(Js.Array.push(signal, signals))

     

       92
        
               | End => ignore(Js.Array.push(signal, signals))

     

       93
       +
               }

     

       94
       +
             );

     

       95
        
       

     

       96
       +
             talkback^(. Pull);

     

       97
       +
             talkback^(. Pull);

     

       98
       +
             talkback^(. Pull); /* one extra to check whether no signal comes back after it has ended */

     

       99
        
       

     

       100
       +
             expect(signals) == [|Push(123), End|];

     

       101
        
           });

     

       102
        
         });

     

       103
        
       

     
···

       106
        
           open! Expect.Operators;

     

       107
        
       

     

       108
        
           it("ends immediately", () => {

     

       109
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       110
        
             let signals = [||];

     

       111
        
       

     

       112
       +
             Wonka.empty((. signal) =>

     

       113
        
               switch (signal) {

     

       114
       +
               | Start(x) => talkback := x

     

       115
        
               | _ => ignore(Js.Array.push(signal, signals))

     

       116
       +
               }

     

       117
       +
             );

     

       118
        
       

     

       119
        
             let _signals = Array.copy(signals);

     

       120
        
       

     

       121
       +
             talkback^(. Pull);

     

       122
       +
             talkback^(. Pull);

     

       123
        
       

     

       124
       +
             expect((_signals, signals)) == ([|End|], [|End|]);

     

       125
        
           });

     

       126
        
         });

     

       127
        
       

     
···

       130
        
           open! Expect.Operators;

     

       131
        
       

     

       132
        
           it("does not end", () => {

     

       133
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       134
        
             let ended = ref(false);

     

       135
        
       

     

       136
       +
             Wonka.never((. signal) =>

     

       137
        
               switch (signal) {

     

       138
       +
               | Start(x) => talkback := x

     

       139
        
               | End => ended := true

     

       140
        
               | _ => ()

     

       141
       +
               }

     

       142
       +
             );

     

       143
        
       

     

       144
       +
             talkback^(. Pull);

     

       145
       +
             talkback^(. Pull);

     

       146
        
       

     

       147
        
             expect(ended^) === false;

     

       148
        
           });

     
···

       156
        
           it("maps all emissions of a source", () => {

     

       157
        
             let num = ref(1);

     

       158
        
             let nums = [||];

     

       159
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       160
        
       

     

       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) =>

     

       178
        
                 switch (signal) {

     

       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);

     

       185
        
                 | _ => ()

     

       186
       +
                 },

     

       187
       +
             );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       188
        
       

     

       189
       +
             expect(nums) |> toEqual([|1, 2, 3, 4|]);

     

       190
        
           });

     

       191
        
       

     

       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
       +
           );

     

       200
        
       

     

       201
       +
           testPromise(

     

       202
       +
             "ends itself and source when its talkback receives the End signal", () => {

     

       203
        
             let end_: talkbackT = Close;

     

       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
       +
                );

     

       211
        
           });

     

       212
        
         });

     

       213
        
       

     
···

       217
        
           it("filters emissions according to a predicate", () => {

     

       218
        
             let i = ref(1);

     

       219
        
             let nums = [||];

     

       220
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       221
        
       

     

       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) =>

     

       238
        
                 switch (signal) {

     

       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);

     

       245
        
                 | _ => ()

     

       246
       +
                 },

     

       247
       +
             );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       248
        
       

     

       249
       +
             expect(nums) |> toEqual([|2, 4|]);

     

       250
        
           });

     

       251
        
       

     

       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
       +
           );

     

       260
        
       

     

       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
       +
           );

     

       269
        
       

     

       270
       +
           testPromise(

     

       271
       +
             "ends itself and source when its talkback receives the End signal", () => {

     

       272
        
             let end_: talkbackT = Close;

     

       273
        
       

     

       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
       +
                );

     

       280
        
           });

     

       281
        
         });

     

       282
        
       

     
···

       284
        
           open Expect;

     

       285
        
       

     

       286
        
           it("folds emissions using an initial seed value", () => {

     

       287
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       288
        
             let num = ref(1);

     

       289
        
       

     

       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
       +
               );

     

       312
        
       

     

       313
        
             let res = [||];

     

       314
        
       

     

       315
       +
             source((. signal) =>

     

       316
        
               switch (signal) {

     

       317
        
               | Start(x) => talkback := x

     

       318
        
               | _ => ignore(Js.Array.push(signal, res))

     

       319
        
               }

     

       320
       +
             );

     

       321
        
       

     

       322
       +
             talkback^(. Pull);

     

       323
       +
             talkback^(. Pull);

     

       324
       +
             talkback^(. Pull);

     

       325
       +
             talkback^(. Pull);

     

       326
       +
             expect(res) |> toEqual([|Push(1), Push(3), Push(6), End|]);

     

       327
        
           });

     

       328
        
       

     

       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
       +
           );

     

       337
        
       

     

       338
       +
           testPromise(

     

       339
       +
             "ends itself and source when its talkback receives the End signal", () => {

     

       340
        
             let end_: talkbackT = Close;

     

       341
        
       

     

       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
       +
                );

     

       348
        
           });

     

       349
        
         });

     

       350
        
       

     
···

       355
        
           it("merges different sources into a single one", () => {

     

       356
        
             let a = Wonka.fromList([1, 2, 3]);

     

       357
        
             let b = Wonka.fromList([4, 5, 6]);

     

       358
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       359
        
             let signals = [||];

     

       360
       +
             let source = Wonka.merge([|a, b|]);

     

       361
        
       

     

       362
       +
             source((. signal) =>

     

       363
        
               switch (signal) {

     

       364
       +
               | Start(x) =>

     

       365
        
                 talkback := x;

     

       366
       +
                 x(. Pull);

     

       367
       +
               | Push(_) =>

     

       0
        
       
     

       368
        
                 ignore(Js.Array.push(signal, signals));

     

       369
       +
                 talkback^(. Pull);

     

       370
       +
               | End => ignore(Js.Array.push(signal, signals))

     

       371
        
               }

     

       372
       +
             );

     

       0
        
       
     

       0
        
       
     

       373
        
       

     

       374
       +
             expect(signals)

     

       375
       +
             == [|Push(1), Push(2), Push(3), Push(4), Push(5), Push(6), End|];

     

       376
        
           });

     

       377
        
       

     

       378
       +
           testPromise("follows the spec for listenables", () =>

     

       379
        
             Wonka_thelpers.testWithListenable(source => Wonka.merge([|source|]))

     

       380
       +
             |> Js.Promise.then_(x =>

     

       381
       +
                  expect(x)

     

       382
       +
                  |> toEqual(([|Pull, Pull, Pull|], [|Push(1), Push(2), End|]))

     

       383
       +
                  |> Js.Promise.resolve

     

       384
       +
                )

     

       385
       +
           );

     

       386
        
       

     

       387
       +
           testPromise(

     

       388
       +
             "ends itself and source when its talkback receives the End signal", () =>

     

       389
        
             Wonka_thelpers.testTalkbackEnd(source => Wonka.merge([|source|]))

     

       390
       +
             |> Js.Promise.then_(x =>

     

       391
       +
                  expect(x)

     

       392
       +
                  |> toEqual(([|Pull, Pull, Close|], [|Push(1)|]))

     

       393
       +
                  |> Js.Promise.resolve

     

       394
       +
                )

     

       395
       +
           );

     

       396
        
         });

     

       397
        
       

     

       398
        
         describe("concat", () => {

     
···

       402
        
           it("concatenates different sources into a single one", () => {

     

       403
        
             let a = Wonka.fromList([1, 2, 3]);

     

       404
        
             let b = Wonka.fromList([4, 5, 6]);

     

       405
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       406
        
             let signals = [||];

     

       407
       +
             let source = Wonka.concat([|a, b|]);

     

       408
        
       

     

       409
       +
             source((. signal) =>

     

       410
        
               switch (signal) {

     

       411
       +
               | Start(x) =>

     

       412
        
                 talkback := x;

     

       413
       +
                 x(. Pull);

     

       414
       +
               | Push(_) =>

     

       0
        
       
     

       415
        
                 ignore(Js.Array.push(signal, signals));

     

       416
       +
                 talkback^(. Pull);

     

       417
       +
               | End => ignore(Js.Array.push(signal, signals))

     

       418
        
               }

     

       419
       +
             );

     

       0
        
       
     

       0
        
       
     

       420
        
       

     

       421
       +
             expect(signals)

     

       422
       +
             == [|Push(1), Push(2), Push(3), Push(4), Push(5), Push(6), End|];

     

       423
        
           });

     

       424
        
       

     

       425
       +
           testPromise("follows the spec for listenables", () =>

     

       426
        
             Wonka_thelpers.testWithListenable(source => Wonka.concat([|source|]))

     

       427
       +
             |> Js.Promise.then_(x =>

     

       428
       +
                  expect(x)

     

       429
       +
                  |> toEqual(([|Pull, Pull, Pull|], [|Push(1), Push(2), End|]))

     

       430
       +
                  |> Js.Promise.resolve

     

       431
       +
                )

     

       432
       +
           );

     

       433
        
       

     

       434
       +
           testPromise(

     

       435
       +
             "ends itself and source when its talkback receives the End signal", () =>

     

       436
        
             Wonka_thelpers.testTalkbackEnd(source => Wonka.concat([|source|]))

     

       437
       +
             |> Js.Promise.then_(x =>

     

       438
       +
                  expect(x)

     

       439
       +
                  |> toEqual(([|Pull, Pull, Close|], [|Push(1)|]))

     

       440
       +
                  |> Js.Promise.resolve

     

       441
       +
                )

     

       442
       +
           );

     

       443
        
         });

     

       444
        
       

     

       445
        
         describe("share", () => {

     

       446
        
           open Expect;

     

       447
        
       

     

       448
        
           it("shares an underlying source with all sinks", () => {

     

       449
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       450
       +
             let aborterTb = ref((. _: Wonka_types.talkbackT) => ());

     

       451
        
             let num = ref(1);

     

       452
        
             let nums = [||];

     

       453
        
       

     

       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
       +
               );

     

       473
        
       

     

       474
       +
             source((. signal) =>

     

       475
        
               switch (signal) {

     

       476
        
               | Start(x) => talkback := x

     

       477
        
               | _ => ignore(Js.Array.push(signal, nums))

     

       478
        
               }

     

       479
       +
             );

     

       480
        
       

     

       481
       +
             source((. signal) =>

     

       482
        
               switch (signal) {

     

       483
        
               | Start(_) => ()

     

       484
        
               | _ => ignore(Js.Array.push(signal, nums))

     

       485
        
               }

     

       486
       +
             );

     

       487
        
       

     

       488
       +
             source((. signal) =>

     

       489
        
               switch (signal) {

     

       490
        
               | Start(tb) => aborterTb := tb

     

       491
       +
               | _ =>

     

       492
        
                 ignore(Js.Array.push(signal, nums));

     

       493
       +
                 aborterTb^(. Close);

     

       494
        
               }

     

       495
       +
             );

     

       0
        
       
     

       496
        
       

     

       497
       +
             talkback^(. Pull);

     

       498
        
             let numsA = Array.copy(nums);

     

       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
       +
                ));

     

       507
        
           });

     

       508
        
       

     

       509
       +
           testPromise("follows the spec for listenables", () =>

     

       510
        
             Wonka_thelpers.testWithListenable(Wonka.share)

     

       511
       +
             |> Js.Promise.then_(x =>

     

       512
       +
                  expect(x)

     

       513
       +
                  |> toEqual(([||], [|Push(1), Push(2), End|]))

     

       514
       +
                  |> Js.Promise.resolve

     

       515
       +
                )

     

       516
       +
           );

     

       517
        
       

     

       518
       +
           testPromise(

     

       519
       +
             "ends itself and source when its talkback receives the End signal", () => {

     

       520
        
             let end_: talkbackT = Close;

     

       521
        
       

     

       522
        
             Wonka_thelpers.testTalkbackEnd(Wonka.share)

     

       523
       +
             |> Js.Promise.then_(x =>

     

       524
       +
                  expect(x)

     

       525
       +
                  |> toEqual(([|end_|], [|Push(1)|]))

     

       526
       +
                  |> Js.Promise.resolve

     

       527
       +
                );

     

       528
        
           });

     

       529
        
         });

     

       530
        
       

     
···

       532
        
           open Expect;

     

       533
        
       

     

       534
        
           it("combines the latest values of two sources", () => {

     

       535
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       536
        
       

     

       537
        
             let makeSource = (factor: int) => {

     

       538
        
               let num = ref(1);

     

       539
        
       

     

       540
        
               sink => {

     

       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
       +
               };

     

       558
        
             };

     

       559
        
       

     

       560
        
             let sourceA = makeSource(1);

     
···

       562
        
             let source = Wonka.combine(sourceA, sourceB);

     

       563
        
             let res = [||];

     

       564
        
       

     

       565
       +
             source((. signal) =>

     

       566
        
               switch (signal) {

     

       567
        
               | Start(x) => talkback := x

     

       568
        
               | _ => ignore(Js.Array.push(signal, res))

     

       569
        
               }

     

       570
       +
             );

     

       571
        
       

     

       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|]);

     

       578
        
           });

     

       579
        
       

     

       580
       +
           testPromise("follows the spec for listenables", () =>

     

       581
        
             Wonka_thelpers.testWithListenable(source => {

     

       582
        
               let shared = Wonka.share(source);

     

       583
       +
               Wonka.combine(shared, shared);

     

       584
        
             })

     

       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
       +
           );

     

       594
        
       

     

       595
       +
           testPromise(

     

       596
       +
             "ends itself and source when its talkback receives the End signal", () => {

     

       597
        
             let end_: talkbackT = Close;

     

       598
        
       

     

       599
        
             Wonka_thelpers.testTalkbackEnd(source => {

     

       600
        
               let shared = Wonka.share(source);

     

       601
       +
               Wonka.combine(shared, shared);

     

       602
        
             })

     

       603
       +
             |> Js.Promise.then_(x =>

     

       604
       +
                  expect(x)

     

       605
       +
                  |> toEqual(([|end_|], [|Push((1, 1))|]))

     

       606
       +
                  |> Js.Promise.resolve

     

       607
       +
                );

     

       608
        
           });

     

       609
        
         });

     

       610
        
       

     
···

       612
        
           open Expect;

     

       613
        
       

     

       614
        
           it("only lets a maximum number of values through", () => {

     

       615
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       616
        
             let num = ref(1);

     

       617
        
       

     

       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
       +
               );

     

       633
        
       

     

       634
        
             let res = [||];

     

       635
        
       

     

       636
       +
             source((. signal) =>

     

       637
        
               switch (signal) {

     

       638
        
               | Start(x) => talkback := x

     

       639
        
               | _ => ignore(Js.Array.push(signal, res))

     

       640
        
               }

     

       641
       +
             );

     

       642
        
       

     

       643
       +
             talkback^(. Pull);

     

       644
       +
             talkback^(. Pull);

     

       645
       +
             talkback^(. Pull);

     

       646
       +
             talkback^(. Pull);

     

       647
       +
             expect(res) |> toEqual([|Push(1), Push(2), End|]);

     

       648
        
           });

     

       649
        
       

     

       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) => ());

     

       654
        
             let num = ref(1);

     

       655
        
       

     

       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
       +
               );

     

       675
        
       

     

       676
        
             let res = [||];

     

       677
        
       

     

       678
       +
             source((. signal) =>

     

       679
        
               switch (signal) {

     

       680
        
               | Start(x) => talkback := x

     

       681
        
               | _ => ignore(Js.Array.push(signal, res))

     

       682
        
               }

     

       683
       +
             );

     

       684
        
       

     

       685
       +
             talkback^(. Pull);

     

       686
       +
             talkback^(. Pull);

     

       687
       +
             talkback^(. Pull);

     

       688
       +
             expect(res) |> toEqual([|Push(1), End|]);

     

       689
        
           });

     

       690
        
       

     

       691
       +
           testPromise("follows the spec for listenables", () =>

     

       692
        
             Wonka_thelpers.testWithListenable(Wonka.take(10))

     

       693
       +
             |> Js.Promise.then_(x =>

     

       694
       +
                  expect(x)

     

       695
       +
                  |> toEqual(([||], [|Push(1), Push(2), End|]))

     

       696
       +
                  |> Js.Promise.resolve

     

       697
       +
                )

     

       698
       +
           );

     

       699
        
       

     

       700
        
           testPromise("follows the spec for listenables when ending the source", () => {

     

       701
        
             let end_: talkbackT = Close;

     

       702
        
       

     

       703
        
             Wonka_thelpers.testWithListenable(Wonka.take(1))

     

       704
       +
             |> Js.Promise.then_(x =>

     

       705
       +
                  expect(x)

     

       706
       +
                  |> toEqual(([|end_|], [|Push(1), End|]))

     

       707
       +
                  |> Js.Promise.resolve

     

       708
       +
                );

     

       709
        
           });

     

       710
        
       

     

       711
       +
           testPromise(

     

       712
       +
             "ends itself and source when its talkback receives the End signal", () => {

     

       713
        
             let end_: talkbackT = Close;

     

       714
        
       

     

       715
        
             Wonka_thelpers.testTalkbackEnd(Wonka.take(10))

     

       716
       +
             |> Js.Promise.then_(x =>

     

       717
       +
                  expect(x)

     

       718
       +
                  |> toEqual(([|end_|], [|Push(1)|]))

     

       719
       +
                  |> Js.Promise.resolve

     

       720
       +
                );

     

       721
        
           });

     

       722
        
         });

     

       723
        
       

     
···

       725
        
           open Expect;

     

       726
        
       

     

       727
        
           it("only lets the last n values through on an entirely new source", () => {

     

       728
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       729
        
             let num = ref(1);

     

       730
        
       

     

       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
       +
               );

     

       747
        
       

     

       748
        
             let res = [||];

     

       749
        
       

     

       750
       +
             source((. signal) =>

     

       751
        
               switch (signal) {

     

       752
        
               | Start(x) => talkback := x

     

       753
        
               | _ => ignore(Js.Array.push(signal, res))

     

       754
        
               }

     

       755
       +
             );

     

       756
        
       

     

       757
       +
             talkback^(. Pull);

     

       758
       +
             talkback^(. Pull);

     

       759
       +
             talkback^(. Pull);

     

       760
       +
             expect(res) |> toEqual([|Push(3), Push(4), End|]);

     

       761
        
           });

     

       762
        
       

     

       763
       +
           testPromise("follows the spec for listenables", () =>

     

       764
        
             Wonka_thelpers.testWithListenable(Wonka.takeLast(10))

     

       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
       +
           );

     

       774
        
       

     

       775
       +
           testPromise(

     

       776
       +
             "ends itself and source when its talkback receives the End signal", () =>

     

       777
        
             Wonka_thelpers.testTalkbackEnd(Wonka.takeLast(10))

     

       778
       +
             |> Js.Promise.then_(x =>

     

       779
       +
                  expect(x)

     

       780
       +
                  |> toEqual(([|Pull, Pull|], [||]))

     

       781
       +
                  |> Js.Promise.resolve

     

       782
       +
                )

     

       783
       +
           );

     

       784
        
         });

     

       785
        
       

     

       786
        
         describe("takeWhile", () => {

     

       787
        
           open Expect;

     

       788
        
       

     

       789
        
           it("only lets the last n values through on an entirely new source", () => {

     

       790
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       791
        
             let num = ref(1);

     

       792
        
       

     

       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
       +
               );

     

       810
        
       

     

       811
        
             let res = [||];

     

       812
        
       

     

       813
       +
             source((. signal) =>

     

       814
        
               switch (signal) {

     

       815
        
               | Start(x) => talkback := x

     

       816
        
               | _ => ignore(Js.Array.push(signal, res))

     

       817
        
               }

     

       818
       +
             );

     

       819
        
       

     

       820
       +
             talkback^(. Pull);

     

       821
       +
             talkback^(. Pull);

     

       822
       +
             talkback^(. Pull);

     

       823
       +
             talkback^(. Pull);

     

       824
        
       

     

       825
       +
             expect(res) |> toEqual([|Push(1), Push(2), End|]);

     

       826
        
           });

     

       827
        
       

     

       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) => ());

     

       832
        
             let num = ref(1);

     

       833
        
       

     

       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
       +
               );

     

       855
        
       

     

       856
        
             let res = [||];

     

       857
        
       

     

       858
       +
             source((. signal) =>

     

       859
        
               switch (signal) {

     

       860
        
               | Start(x) => talkback := x

     

       861
        
               | _ => ignore(Js.Array.push(signal, res))

     

       862
        
               }

     

       863
       +
             );

     

       864
        
       

     

       865
       +
             talkback^(. Pull);

     

       866
       +
             talkback^(. Pull);

     

       867
       +
             talkback^(. Pull);

     

       868
        
       

     

       869
       +
             expect(res) |> toEqual([|Push(1), End|]);

     

       870
        
           });

     

       871
        
       

     

       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
       +
           );

     

       880
        
       

     

       881
        
           testPromise("follows the spec for listenables when ending the source", () => {

     

       882
        
             let end_: talkbackT = Close;

     

       883
        
       

     

       884
       +
             Wonka_thelpers.testWithListenable(Wonka.takeWhile((. _) => false))

     

       885
       +
             |> Js.Promise.then_(x =>

     

       886
       +
                  expect(x) |> toEqual(([|end_|], [|End|])) |> Js.Promise.resolve

     

       887
       +
                );

     

       0
        
       
     

       0
        
       
     

       888
        
           });

     

       889
        
       

     

       890
       +
           testPromise(

     

       891
       +
             "ends itself and source when its talkback receives the End signal", () => {

     

       892
        
             let end_: talkbackT = Close;

     

       893
        
       

     

       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
       +
                );

     

       900
        
           });

     

       901
        
         });

     

       902
        
       

     
···

       904
        
           open Expect;

     

       905
        
       

     

       906
        
           it("only lets the last n values through on an entirely new source", () => {

     

       907
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       908
        
             let notify = ref((_: Wonka_types.talkbackT) => ());

     

       909
        
             let num = ref(1);

     

       910
        
       

     

       911
        
             let notifier = sink => {

     

       912
       +
               notify :=

     

       913
       +
                 (

     

       914
       +
                   signal =>

     

       915
       +
                     switch (signal) {

     

       916
       +
                     | Pull => sink(. Push(0))

     

       917
       +
                     | _ => ()

     

       918
       +
                     }

     

       919
       +
                 );

     

       920
        
       

     

       921
       +
               sink(. Start(Wonka_helpers.talkbackPlaceholder));

     

       922
        
             };

     

       923
        
       

     

       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
       +
               );

     

       942
        
       

     

       943
        
             let res = [||];

     

       944
        
       

     

       945
       +
             source((. signal) =>

     

       946
        
               switch (signal) {

     

       947
        
               | Start(x) => talkback := x

     

       948
        
               | _ => ignore(Js.Array.push(signal, res))

     

       949
        
               }

     

       950
       +
             );

     

       951
        
       

     

       952
       +
             talkback^(. Pull);

     

       953
       +
             talkback^(. Pull);

     

       954
       +
             talkback^(. Pull);

     

       955
       +
             talkback^(. Pull);

     

       956
        
       

     

       957
       +
             expect(res) |> toEqual([|Push(1), Push(2), End|]);

     

       958
        
           });

     

       959
        
       

     

       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) => ());

     

       964
        
             let num = ref(1);

     

       965
       +
             let notifier = sink =>

     

       966
       +
               sink(. Start(Wonka_helpers.talkbackPlaceholder));

     

       967
        
       

     

       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
       +
               );

     

       987
        
       

     

       988
        
             let res = [||];

     

       989
        
       

     

       990
       +
             source((. signal) =>

     

       991
        
               switch (signal) {

     

       992
        
               | Start(x) => talkback := x

     

       993
        
               | _ => ignore(Js.Array.push(signal, res))

     

       994
        
               }

     

       995
       +
             );

     

       996
        
       

     

       997
       +
             talkback^(. Pull);

     

       998
       +
             talkback^(. Pull);

     

       999
       +
             talkback^(. Pull);

     

       1000
       +
             talkback^(. Pull);

     

       1001
        
       

     

       1002
       +
             expect(res) |> toEqual([|Push(1), Push(2), End|]);

     

       1003
        
           });

     

       1004
        
       

     

       1005
       +
           testPromise("follows the spec for listenables", () =>

     

       1006
        
             Wonka_thelpers.testWithListenable(Wonka.takeUntil(Wonka.never))

     

       1007
       +
             |> Js.Promise.then_(x =>

     

       1008
       +
                  expect(x)

     

       1009
       +
                  |> toEqual(([||], [|Push(1), Push(2), End|]))

     

       1010
       +
                  |> Js.Promise.resolve

     

       1011
       +
                )

     

       1012
       +
           );

     

       1013
        
       

     

       1014
        
           testPromise("follows the spec for listenables when ending the source", () => {

     

       1015
        
             let end_: talkbackT = Close;

     

       1016
        
       

     

       1017
        
             Wonka_thelpers.testWithListenable(Wonka.takeUntil(Wonka.fromValue(0)))

     

       1018
       +
             |> Js.Promise.then_(x =>

     

       1019
       +
                  expect(x) |> toEqual(([|end_|], [|End|])) |> Js.Promise.resolve

     

       1020
       +
                );

     

       0
        
       
     

       0
        
       
     

       1021
        
           });

     

       1022
        
       

     

       1023
       +
           testPromise(

     

       1024
       +
             "ends itself and source when its talkback receives the End signal", () => {

     

       1025
        
             let end_: talkbackT = Close;

     

       1026
        
       

     

       1027
        
             Wonka_thelpers.testTalkbackEnd(Wonka.takeUntil(Wonka.never))

     

       1028
       +
             |> Js.Promise.then_(x =>

     

       1029
       +
                  expect(x)

     

       1030
       +
                  |> toEqual(([|end_|], [|Push(1)|]))

     

       1031
       +
                  |> Js.Promise.resolve

     

       1032
       +
                );

     

       1033
        
           });

     

       1034
        
         });

     

       1035
        
       

     

       1036
        
         describe("skip", () => {

     

       1037
        
           open Expect;

     

       1038
        
       

     

       1039
       +
           it(

     

       1040
       +
             "only lets values through after a number of values have been filtered out",

     

       1041
       +
             () => {

     

       1042
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       1043
        
             let num = ref(1);

     

       1044
        
       

     

       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
       +
               );

     

       1061
        
       

     

       1062
        
             let res = [||];

     

       1063
        
       

     

       1064
       +
             source((. signal) =>

     

       1065
        
               switch (signal) {

     

       1066
        
               | Start(x) => talkback := x

     

       1067
        
               | _ => ignore(Js.Array.push(signal, res))

     

       1068
        
               }

     

       1069
       +
             );

     

       1070
        
       

     

       1071
       +
             talkback^(. Pull);

     

       1072
       +
             talkback^(. Pull);

     

       1073
       +
             talkback^(. Pull);

     

       1074
       +
             expect(res) |> toEqual([|Push(3), Push(4), End|]);

     

       1075
        
           });

     

       1076
        
       

     

       1077
       +
           testPromise("follows the spec for listenables", () =>

     

       1078
        
             Wonka_thelpers.testWithListenable(Wonka.skip(0))

     

       1079
       +
             |> Js.Promise.then_(x =>

     

       1080
       +
                  expect(x)

     

       1081
       +
                  |> toEqual(([||], [|Push(1), Push(2), End|]))

     

       1082
       +
                  |> Js.Promise.resolve

     

       1083
       +
                )

     

       1084
       +
           );

     

       1085
        
       

     

       1086
       +
           testPromise(

     

       1087
       +
             "follows the spec for listenables when skipping the source", () =>

     

       1088
        
             Wonka_thelpers.testWithListenable(Wonka.skip(10))

     

       1089
       +
             |> Js.Promise.then_(x =>

     

       1090
       +
                  expect(x)

     

       1091
       +
                  |> toEqual(([|Pull, Pull|], [|End|]))

     

       1092
       +
                  |> Js.Promise.resolve

     

       1093
       +
                )

     

       1094
       +
           );

     

       1095
        
       

     

       1096
       +
           testPromise(

     

       1097
       +
             "ends itself and source when its talkback receives the End signal", () => {

     

       1098
        
             let end_: talkbackT = Close;

     

       1099
        
       

     

       1100
        
             Wonka_thelpers.testTalkbackEnd(Wonka.skip(10))

     

       1101
       +
             |> Js.Promise.then_(x =>

     

       1102
       +
                  expect(x)

     

       1103
       +
                  |> toEqual(([|Pull, end_|], [||]))

     

       1104
       +
                  |> Js.Promise.resolve

     

       1105
       +
                );

     

       1106
        
           });

     

       1107
        
         });

     

       1108
        
       

     

       1109
        
         describe("skipWhile", () => {

     

       1110
        
           open Expect;

     

       1111
        
       

     

       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);

     

       1117
        
       

     

       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
       +
                 );

     

       1136
        
       

     

       1137
       +
               let res = [||];

     

       1138
        
       

     

       1139
       +
               source((. signal) =>

     

       1140
       +
                 switch (signal) {

     

       1141
       +
                 | Start(x) => talkback := x

     

       1142
       +
                 | _ => ignore(Js.Array.push(signal, res))

     

       1143
       +
                 }

     

       1144
       +
               );

     

       1145
        
       

     

       1146
       +
               talkback^(. Pull);

     

       1147
       +
               talkback^(. Pull);

     

       1148
       +
               talkback^(. Pull);

     

       1149
       +
               expect(res) |> toEqual([|Push(3), Push(4), End|]);

     

       1150
       +
             },

     

       1151
       +
           );

     

       1152
        
       

     

       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
       +
           );

     

       1161
        
       

     

       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
       +
           );

     

       1171
        
       

     

       1172
       +
           testPromise(

     

       1173
       +
             "ends itself and source when its talkback receives the End signal", () => {

     

       1174
        
             let end_: talkbackT = Close;

     

       1175
        
       

     

       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
       +
                );

     

       1182
        
           });

     

       1183
        
         });

     

       1184
        
       

     
···

       1186
        
           open Expect;

     

       1187
        
       

     

       1188
        
           it("only lets values through after the notifier emits a value", () => {

     

       1189
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       1190
        
             let notify = ref((_: Wonka_types.talkbackT) => ());

     

       1191
        
             let num = ref(1);

     

       1192
        
       

     

       1193
        
             let notifier = sink => {

     

       1194
       +
               notify :=

     

       1195
       +
                 (

     

       1196
       +
                   signal =>

     

       1197
       +
                     switch (signal) {

     

       1198
       +
                     | Pull => sink(. Push(0))

     

       1199
       +
                     | _ => ()

     

       1200
       +
                     }

     

       1201
       +
                 );

     

       1202
        
       

     

       1203
       +
               sink(. Start(Wonka_helpers.talkbackPlaceholder));

     

       1204
        
             };

     

       1205
        
       

     

       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
       +
               );

     

       1225
        
       

     

       1226
        
             let res = [||];

     

       1227
        
       

     

       1228
       +
             source((. signal) =>

     

       1229
        
               switch (signal) {

     

       1230
        
               | Start(x) => talkback := x

     

       1231
        
               | _ => ignore(Js.Array.push(signal, res))

     

       1232
        
               }

     

       1233
       +
             );

     

       1234
        
       

     

       1235
       +
             talkback^(. Pull);

     

       1236
       +
             talkback^(. Pull);

     

       1237
       +
             talkback^(. Pull);

     

       1238
       +
             talkback^(. Pull);

     

       1239
        
       

     

       1240
       +
             expect(res) |> toEqual([|Push(3), Push(4), End|]);

     

       1241
        
           });

     

       1242
        
       

     

       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) => ());

     

       1247
        
             let num = ref(1);

     

       1248
       +
             let notifier = sink =>

     

       1249
       +
               sink(. Start(Wonka_helpers.talkbackPlaceholder));

     

       1250
        
       

     

       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
       +
               );

     

       1270
        
       

     

       1271
        
             let res = [||];

     

       1272
        
       

     

       1273
       +
             source((. signal) =>

     

       1274
        
               switch (signal) {

     

       1275
        
               | Start(x) => talkback := x

     

       1276
        
               | _ => ignore(Js.Array.push(signal, res))

     

       1277
        
               }

     

       1278
       +
             );

     

       1279
        
       

     

       1280
       +
             talkback^(. Pull);

     

       1281
       +
             talkback^(. Pull);

     

       1282
       +
             talkback^(. Pull);

     

       1283
        
       

     

       1284
       +
             expect(res) |> toEqual([|End|]);

     

       1285
        
           });

     

       1286
        
       

     

       1287
       +
           testPromise("follows the spec for listenables", () =>

     

       1288
        
             Wonka_thelpers.testWithListenable(Wonka.skipUntil(Wonka.never))

     

       1289
       +
             |> Js.Promise.then_(x =>

     

       1290
       +
                  expect(x)

     

       1291
       +
                  |> toEqual(([|Pull, Pull, Pull|], [|End|]))

     

       1292
       +
                  |> Js.Promise.resolve

     

       1293
       +
                )

     

       1294
       +
           );

     

       1295
        
       

     

       1296
       +
           testPromise(

     

       1297
       +
             "follows the spec for listenables when skipping the source", () =>

     

       1298
        
             Wonka_thelpers.testWithListenable(Wonka.skipUntil(Wonka.fromValue(0)))

     

       1299
       +
             |> Js.Promise.then_(x =>

     

       1300
       +
                  expect(x)

     

       1301
       +
                  |> toEqual(([|Pull|], [|Push(1), Push(2), End|]))

     

       1302
       +
                  |> Js.Promise.resolve

     

       1303
       +
                )

     

       1304
       +
           );

     

       1305
        
       

     

       1306
       +
           testPromise(

     

       1307
       +
             "ends itself and source when its talkback receives the End signal", () => {

     

       1308
        
             let end_: talkbackT = Close;

     

       1309
        
       

     

       1310
        
             Wonka_thelpers.testTalkbackEnd(Wonka.skipUntil(Wonka.fromValue(0)))

     

       1311
       +
             |> Js.Promise.then_(x =>

     

       1312
       +
                  expect(x)

     

       1313
       +
                  |> toEqual(([|Pull, end_|], [|Push(1)|]))

     

       1314
       +
                  |> Js.Promise.resolve

     

       1315
       +
                );

     

       1316
        
           });

     

       1317
        
         });

     

       1318
        
       

     

       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;

     

       1326
        
       

     

       1327
       +
               let res = [||];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1328
        
       

     

       1329
       +
               source((. signal) =>

     

       1330
       +
                 switch (signal) {

     

       1331
       +
                 | Start(x) => talkback := x

     

       1332
       +
                 | _ => ignore(Js.Array.push(signal, res))

     

       1333
       +
                 }

     

       1334
       +
               );

     

       1335
        
       

     

       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
       +
         );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1346
        
       

     

       1347
        
         describe("switchMap", () => {

     

       1348
        
           afterEach(() => Jest.useRealTimers());

     

       0
        
       
     

       1349
        
           open Expect;

     

       1350
        
           open! Expect.Operators;

     

       1351
        
       

     
···

       1354
        
       

     

       1355
        
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       1356
        
             let signals = [||];

     

       1357
       +
             let source = Wonka.switchMap((. x) => Wonka.fromList([x * x]), a);

     

       1358
        
       

     

       1359
       +
             source((. signal) =>

     

       1360
        
               switch (signal) {

     

       1361
        
               | Start(x) =>

     

       1362
        
                 talkback := x;

     

       1363
       +
                 x(. Pull);

     

       1364
        
               | Push(_) =>

     

       1365
        
                 ignore(Js.Array.push(signal, signals));

     

       1366
       +
                 talkback^(. Pull);

     

       1367
        
               | End => ignore(Js.Array.push(signal, signals))

     

       1368
        
               }

     

       1369
        
             );

     
···

       1376
        
       

     

       1377
        
             let a = Wonka.interval(100);

     

       1378
        
       

     

       1379
       +
             let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       1380
        
             let signals = [||];

     

       1381
        
             let source =

     

       1382
       +
               Wonka.switchMap((. _) => Wonka.interval(25), a) |> Wonka.take(5);

     

       1383
        
       

     

       1384
       +
             source((. signal) =>

     

       1385
        
               switch (signal) {

     

       1386
        
               | Start(x) =>

     

       1387
        
                 talkback := x;

     

       1388
       +
                 x(. Pull);

     

       1389
        
               | Push(_) =>

     

       1390
        
                 ignore(Js.Array.push(signal, signals));

     

       1391
       +
                 talkback^(. Pull);

     

       1392
        
               | End => ignore(Js.Array.push(signal, signals))

     

       1393
        
               }

     

       1394
        
             );

     
···

       1401
        
       

     

       1402
        
           testPromise("follows the spec for listenables", () =>

     

       1403
        
             Wonka_thelpers.testWithListenable(source =>

     

       1404
       +
               Wonka.switchMap((. x) => x, Wonka.fromList([source]))

     

       1405
        
             )

     

       1406
        
             |> Js.Promise.then_(x =>

     

       1407
        
                  expect(x)

     
···

       1413
        
           testPromise(

     

       1414
        
             "ends itself and source when its talkback receives the End signal", () =>

     

       1415
        
             Wonka_thelpers.testTalkbackEnd(source =>

     

       1416
       +
               Wonka.switchMap((. x) => x, Wonka.fromList([source]))

     

       1417
        
             )

     

       1418
        
             |> Js.Promise.then_(x =>

     

       1419
        
                  expect(x)

     
···

       1425
        
       });

     

       1426
        
       

     

       1427
        
       describe("sink factories", () => {

     

       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 = [||];

     

       1433
        
       

     

       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
       +
               };

     

       1449
        
       

     

       1450
       +
               Wonka.forEach((. x) => ignore(Js.Array.push(x, nums)), source);

     

       1451
       +
               expect(nums) |> toEqual([|0, 1, 2, 3|]);

     

       1452
       +
             })

     

       1453
       +
           )

     

       1454
       +
         );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1455
        
       

     

       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(() => ());

     

       1464
        
       

     

       1465
       +
                 let source = sink => {

     

       1466
       +
                   push :=

     

       1467
       +
                     (

     

       1468
       +
                       () => {

     

       1469
       +
                         let num = i^;

     

       1470
       +
                         i := i^ + 1;

     

       1471
       +
                         sink(. Push(num));

     

       1472
       +
                       }

     

       1473
       +
                     );

     

       1474
        
       

     

       1475
       +
                   sink(. Start(Wonka_helpers.talkbackPlaceholder));

     

       1476
       +
                 };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1477
        
       

     

       1478
       +
                 let {unsubscribe} =

     

       1479
       +
                   Wonka.subscribe(

     

       1480
       +
                     (. x) => ignore(Js.Array.push(x, nums)),

     

       1481
       +
                     source,

     

       1482
       +
                   );

     

       1483
        
       

     

       1484
       +
                 push^();

     

       1485
       +
                 push^();

     

       1486
       +
                 unsubscribe();

     

       1487
       +
                 push^();

     

       1488
       +
                 push^();

     

       1489
        
       

     

       1490
       +
                 expect(nums) |> toEqual([|0, 1|]);

     

       1491
       +
               },

     

       1492
       +
             )

     

       1493
       +
           )

     

       1494
       +
         );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1495
        
       });

     

       1496
        
       

     

       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 = [||];

     

       1503
        
       

     

       1504
       +
             input

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1505
        
             |> Wonka.fromArray

     

       1506
       +
             |> Wonka.map((. x) => string_of_int(x))

     

       1507
       +
             |> Wonka.forEach((. x) => ignore(Js.Array.push(x, actual)));

     

       1508
        
       

     

       1509
       +
             expect(output) |> toEqual(output);

     

       1510
       +
           })

     

       1511
       +
         )

     

       1512
       +
       );

     

       1513
        
       

     

       1514
        
       describe("subject", () => {

     

       1515
        
         open Expect;

     
···

       1520
        
       

     

       1521
        
           let subject = Wonka.makeSubject();

     

       1522
        
       

     

       1523
       +
           subject.source((. signal) =>

     

       1524
        
             switch (signal) {

     

       1525
        
             | Start(_) => ignore()

     

       1526
        
             | Push(_) => ignore(Js.Array.push(signal, signals))

     
···

       1538
        
         });

     

       1539
        
       

     

       1540
        
         it("handles multiple sinks", () => {

     

       1541
       +
           let talkback = ref((. _: Wonka_types.talkbackT) => ());

     

       1542
        
           let signalsOne = [||];

     

       1543
        
           let signalsTwo = [||];

     

       1544
        
       

     

       1545
        
           let subject = Wonka.makeSubject();

     

       1546
        
       

     

       1547
       +
           subject.source((. signal) =>

     

       1548
        
             switch (signal) {

     

       1549
        
             | Start(x) => talkback := x

     

       1550
        
             | Push(_) => ignore(Js.Array.push(signal, signalsOne))

     
···

       1552
        
             }

     

       1553
        
           );

     

       1554
        
       

     

       1555
       +
           subject.source((. signal) =>

     

       1556
        
             switch (signal) {

     

       1557
        
             | Start(_) => ignore()

     

       1558
        
             | Push(_) => ignore(Js.Array.push(signal, signalsTwo))

     
···

       1564
        
           subject.next(20);

     

       1565
        
           subject.next(30);

     

       1566
        
       

     

       1567
       +
           talkback^(. Close);

     

       1568
        
       

     

       1569
        
           subject.next(40);

     

       1570
        
           subject.next(50);

     
···

       1579
        
         });

     

       1580
        
       

     

       1581
        
         it("handles multiple sinks that subscribe and close at different times", () => {

     

       1582
       +
           let talkbackOne = ref((. _: Wonka_types.talkbackT) => ());

     

       1583
       +
           let talkbackTwo = ref((. _: Wonka_types.talkbackT) => ());

     

       1584
        
           let signalsOne = [||];

     

       1585
        
           let signalsTwo = [||];

     

       1586
        
       

     
···

       1589
        
           subject.next(10);

     

       1590
        
           subject.next(20);

     

       1591
        
       

     

       1592
       +
           subject.source((. signal) =>

     

       1593
        
             switch (signal) {

     

       1594
        
             | Start(x) => talkbackOne := x

     

       1595
        
             | Push(_) => ignore(Js.Array.push(signal, signalsOne))

     
···

       1599
        
       

     

       1600
        
           subject.next(30);

     

       1601
        
       

     

       1602
       +
           subject.source((. signal) =>

     

       1603
        
             switch (signal) {

     

       1604
        
             | Start(x) => talkbackTwo := x

     

       1605
        
             | Push(_) => ignore(Js.Array.push(signal, signalsTwo))

     
···

       1610
        
           subject.next(40);

     

       1611
        
           subject.next(50);

     

       1612
        
       

     

       1613
       +
           talkbackTwo^(. Close);

     

       1614
        
       

     

       1615
        
           subject.next(60);

     

       1616
        
       

     

       1617
       +
           talkbackOne^(. Close);

     

       1618
        
       

     

       1619
        
           subject.next(70);

     

       1620
        
           subject.complete();

+42 -31

__tests__/wonka_thelpers.re

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
        
       let testWithListenable = operator => {

     

       4
       -
         let sink = ref((._: signalT(int)) => ());

     

       5
        
         let signals = [||];

     

       6
        
         let source = x => {

     

       7
        
           sink := x;

     

       8
       -
           x(.Start((.signal) => {

     

       9
       -
             ignore(Js.Array.push(signal, signals))

     

       10
       -
           }));

     

       11
        
         };

     

       12
        
       

     

       13
       -
         let talkback = ref((._: talkbackT) => ());

     

       14
        
         let res = [||];

     

       15
       -
         operator(source)((.signal) => {

     

       16
        
           switch (signal) {

     

       17
        
           | Start(x) => talkback := x

     

       18
        
           | _ => ignore(Js.Array.push(signal, res))

     

       19
        
           }

     

       20
       -
         });

     

       21
        
       

     

       22
        
         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
       -
         })

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       34
        
       };

     

       35
        
       

     

       36
        
       let testTalkbackEnd = operator => {

     

       37
       -
         let sink = ref((._: signalT(int)) => ());

     

       38
        
         let signals: array(talkbackT) = [||];

     

       39
        
         let source = x => {

     

       40
       -
           x(.Start((.signal) => ignore(Js.Array.push(signal, signals))));

     

       41
        
           sink := x;

     

       42
        
         };

     

       43
        
       

     

       44
       -
         let talkback = ref((._: talkbackT) => ());

     

       45
        
         let res = [||];

     

       46
       -
         operator(source)((.signal) => {

     

       47
        
           switch (signal) {

     

       48
        
           | Start(x) => talkback := x

     

       49
        
           | _ => ignore(Js.Array.push(signal, res))

     

       50
        
           }

     

       51
       -
         });

     

       52
        
       

     

       53
        
         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
       -
         })

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       62
        
       };

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
        
       let testWithListenable = operator => {

     

       4
       +
         let sink = ref((. _: signalT(int)) => ());

     

       5
        
         let signals = [||];

     

       6
        
         let source = x => {

     

       7
        
           sink := x;

     

       8
       +
           x(. Start((. signal) => ignore(Js.Array.push(signal, signals))));

     

       0
        
       
     

       0
        
       
     

       9
        
         };

     

       10
        
       

     

       11
       +
         let talkback = ref((. _: talkbackT) => ());

     

       12
        
         let res = [||];

     

       13
       +
         operator(source, (. signal) =>

     

       14
        
           switch (signal) {

     

       15
        
           | Start(x) => talkback := x

     

       16
        
           | _ => ignore(Js.Array.push(signal, res))

     

       17
        
           }

     

       18
       +
         );

     

       19
        
       

     

       20
        
         Js.Promise.make((~resolve, ~reject as _) => {

     

       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
       +
         });

     

       42
        
       };

     

       43
        
       

     

       44
        
       let testTalkbackEnd = operator => {

     

       45
       +
         let sink = ref((. _: signalT(int)) => ());

     

       46
        
         let signals: array(talkbackT) = [||];

     

       47
        
         let source = x => {

     

       48
       +
           x(. Start((. signal) => ignore(Js.Array.push(signal, signals))));

     

       49
        
           sink := x;

     

       50
        
         };

     

       51
        
       

     

       52
       +
         let talkback = ref((. _: talkbackT) => ());

     

       53
        
         let res = [||];

     

       54
       +
         operator(source, (. signal) =>

     

       55
        
           switch (signal) {

     

       56
        
           | Start(x) => talkback := x

     

       57
        
           | _ => ignore(Js.Array.push(signal, res))

     

       58
        
           }

     

       59
       +
         );

     

       60
        
       

     

       61
        
         Js.Promise.make((~resolve, ~reject as _) => {

     

       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
       +
         });

     

       73
        
       };

+14

package.json

···

       26
        
           "terser:cjs": "terser --config-file .terser.config.json -o ./dist/wonka.js ./dist/wonka.js",

     

       27
        
           "terser": "run-p terser:es terser:cjs",

     

       28
        
           "prettier": "prettier --write ./dist/*.js",

     

       0
        
       
     

       29
        
           "prebundle": "rimraf ./dist",

     

       30
        
           "bundle": "microbundle --external none --no-compress --no-sourcemap --format es,cjs",

     

       31
        
           "postbundle": "run-s terser prettier",

     
···

       55
        
           "bs-platform": "^4.0.17",

     

       56
        
           "bundlesize": "^0.17.0",

     

       57
        
           "coveralls": "^3.0.0",

     

       0
        
       
     

       0
        
       
     

       58
        
           "microbundle": "^0.9.0",

     

       59
        
           "npm-run-all": "^4.1.5",

     

       60
        
           "prettier": "^1.15.3",

     

       61
        
           "rimraf": "^2.6.3",

     

       62
        
           "terser": "^3.14.1"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       63
        
         },

     

       64
        
         "prettier": {

     

       65
        
           "printWidth": 100

···

       26
        
           "terser:cjs": "terser --config-file .terser.config.json -o ./dist/wonka.js ./dist/wonka.js",

     

       27
        
           "terser": "run-p terser:es terser:cjs",

     

       28
        
           "prettier": "prettier --write ./dist/*.js",

     

       29
       +
           "refmt": "bsrefmt --in-place **/**/*.re",

     

       30
        
           "prebundle": "rimraf ./dist",

     

       31
        
           "bundle": "microbundle --external none --no-compress --no-sourcemap --format es,cjs",

     

       32
        
           "postbundle": "run-s terser prettier",

     
···

       56
        
           "bs-platform": "^4.0.17",

     

       57
        
           "bundlesize": "^0.17.0",

     

       58
        
           "coveralls": "^3.0.0",

     

       59
       +
           "husky": "^1.3.1",

     

       60
       +
           "lint-staged": "^8.1.5",

     

       61
        
           "microbundle": "^0.9.0",

     

       62
        
           "npm-run-all": "^4.1.5",

     

       63
        
           "prettier": "^1.15.3",

     

       64
        
           "rimraf": "^2.6.3",

     

       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
       +
           }

     

       77
        
         },

     

       78
        
         "prettier": {

     

       79
        
           "printWidth": 100

+70 -72

src/operators/wonka_operator_combine.re

···

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
        
       type combineStateT('a, 'b) = {

     

       5
       -
         mutable talkbackA: (.talkbackT) => unit,

     

       6
       -
         mutable talkbackB: (.talkbackT) => unit,

     

       7
        
         mutable lastValA: option('a),

     

       8
        
         mutable lastValB: option('b),

     

       9
        
         mutable gotSignal: bool,

     
···

       11
        
         mutable ended: bool,

     

       12
        
       };

     

       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
       -
         };

     

       0
        
       
     

       0
        
       
     

       24
        
       

     

       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
       -
         });

     

       46
        
       

     

       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
       -
         });

     

       68
        
       

     

       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
       -
       }));

     

       0
        
       
     

       0

···

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
        
       type combineStateT('a, 'b) = {

     

       5
       +
         mutable talkbackA: (. talkbackT) => unit,

     

       6
       +
         mutable talkbackB: (. talkbackT) => unit,

     

       7
        
         mutable lastValA: option('a),

     

       8
        
         mutable lastValB: option('b),

     

       9
        
         mutable gotSignal: bool,

     
···

       11
        
         mutable ended: bool,

     

       12
        
       };

     

       13
        
       

     

       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
       +
             };

     

       26
        
       

     

       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
       +
             );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       45
        
       

     

       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
       +
             );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       64
        
       

     

       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

···

       3
        
       

     

       4
        
       type concatMapStateT('a) = {

     

       5
        
         inputQueue: Rebel.MutableQueue.t('a),

     

       6
       -
         mutable outerTalkback: (.talkbackT) => unit,

     

       7
       -
         mutable innerTalkback: (.talkbackT) => unit,

     

       8
        
         mutable innerActive: bool,

     

       9
        
         mutable closed: bool,

     

       10
       -
         mutable ended: bool

     

       11
        
       };

     

       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
       -
         };

     

       0
        
       
     

       0
        
       
     

       22
        
       

     

       23
       -
         let rec applyInnerSource = innerSource =>

     

       24
       -
           innerSource((.signal) => {

     

       25
       -
             switch (signal) {

     

       26
       -
             | End => {

     

       27
       -
               state.innerActive = false;

     

       28
       -
               state.innerTalkback = talkbackPlaceholder;

     

       29
        
       

     

       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
       -
           });

     

       48
        
       

     

       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
       -
             }

     

       68
        
       

     

       69
       -
             state.outerTalkback(.Pull);

     

       70
       -
           }

     

       71
       -
           | Push(_) => ()

     

       72
       -
           }

     

       73
       -
         });

     

       74
        
       

     

       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
       -
       }));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       90
        
       

     

       91
       -
       let concatAll = source => concatMap((.x) => x, source);

     

       92
        
       

     

       93
        
       let concat = sources => {

     

       94
       -
         open Wonka_source_fromArray;

     

       95
       -
         concatMap((.x) => x, fromArray(sources));

     

       96
        
       };

···

       3
        
       

     

       4
        
       type concatMapStateT('a) = {

     

       5
        
         inputQueue: Rebel.MutableQueue.t('a),

     

       6
       +
         mutable outerTalkback: (. talkbackT) => unit,

     

       7
       +
         mutable innerTalkback: (. talkbackT) => unit,

     

       8
        
         mutable innerActive: bool,

     

       9
        
         mutable closed: bool,

     

       10
       +
         mutable ended: bool,

     

       11
        
       };

     

       12
        
       

     

       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
       +
             };

     

       24
        
       

     

       25
       +
             let rec applyInnerSource = innerSource =>

     

       26
       +
               innerSource((. signal) =>

     

       27
       +
                 switch (signal) {

     

       28
       +
                 | End =>

     

       29
       +
                   state.innerActive = false;

     

       30
       +
                   state.innerTalkback = talkbackPlaceholder;

     

       31
        
       

     

       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
       +
               );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       47
        
       

     

       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
       +
                 };

     

       0
        
       
     

       66
        
       

     

       67
       +
                 state.outerTalkback(. Pull);

     

       68
       +
               | Push(_) => ()

     

       69
       +
               }

     

       70
       +
             );

     

       0
        
       
     

       71
        
       

     

       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
       +
         );

     

       93
        
       

     

       94
       +
       let concatAll = source => concatMap((. x) => x, source);

     

       95
        
       

     

       96
        
       let concat = sources => {

     

       97
       +
         Wonka_source_fromArray.(concatMap((. x) => x, fromArray(sources)));

     

       0
        
       
     

       98
        
       };

+11 -8

src/operators/wonka_operator_filter.re

···

       1
        
       open Wonka_types;

     

       2
        
       open Wonka_helpers;

     

       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
       -
       }));

     

       0
        
       
     

       0
        
       
     

       0

···

       1
        
       open Wonka_types;

     

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       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

···

       1
        
       open Wonka_types;

     

       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
       -
       }));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       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

···

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
        
       type mergeMapStateT = {

     

       5
       -
         mutable outerTalkback: (.talkbackT) => unit,

     

       6
       -
         mutable innerTalkbacks: Rebel.Array.t((.talkbackT) => unit),

     

       7
       -
         mutable ended: bool

     

       8
        
       };

     

       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
       -
         };

     

       0
        
       
     

       0
        
       
     

       16
        
       

     

       17
       -
         let applyInnerSource = innerSource => {

     

       18
       -
           let talkback = ref(talkbackPlaceholder);

     

       19
        
       

     

       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
       -
         };

     

       41
        
       

     

       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
       -
         });

     

       62
        
       

     

       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
       -
       }));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       80
        
       

     

       81
        
       let merge = sources => {

     

       82
       -
         open Wonka_source_fromArray;

     

       83
       -
         mergeMap((.x) => x, fromArray(sources));

     

       84
        
       };

     

       85
        
       

     

       86
       -
       let mergeAll = source => mergeMap((.x) => x, source);

     

       87
        
       let flatten = mergeAll;

···

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
        
       type mergeMapStateT = {

     

       5
       +
         mutable outerTalkback: (. talkbackT) => unit,

     

       6
       +
         mutable innerTalkbacks: Rebel.Array.t((. talkbackT) => unit),

     

       7
       +
         mutable ended: bool,

     

       8
        
       };

     

       9
        
       

     

       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
       +
             };

     

       18
        
       

     

       19
       +
             let applyInnerSource = innerSource => {

     

       20
       +
               let talkback = ref(talkbackPlaceholder);

     

       21
        
       

     

       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
       +
             };

     

       0
        
       
     

       42
        
       

     

       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
       +
             );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       60
        
       

     

       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
       +
         );

     

       87
        
       

     

       88
        
       let merge = sources => {

     

       89
       +
         Wonka_source_fromArray.(mergeMap((. x) => x, fromArray(sources)));

     

       0
        
       
     

       90
        
       };

     

       91
        
       

     

       92
       +
       let mergeAll = source => mergeMap((. x) => x, source);

     

       93
        
       let flatten = mergeAll;

+28 -25

src/operators/wonka_operator_onEnd.re

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       -
       let onEnd = f => curry(source => curry(sink => {

     

       4
       -
         let ended = ref(false);

     

       0
        
       
     

       0
        
       
     

       5
        
       

     

       6
       -
         source((.signal) => {

     

       7
       -
           switch (signal) {

     

       8
       -
           | Start(talkback) => {

     

       9
       -
             sink(.Start((.signal) => {

     

       10
        
               switch (signal) {

     

       11
       -
               | Close when !ended^ => {

     

       12
       -
                 ended := true;

     

       13
       -
                 f(.);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
               }

     

       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
       -
       }));

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       +
       let onEnd = f =>

     

       4
       +
         curry(source =>

     

       5
       +
           curry(sink => {

     

       6
       +
             let ended = ref(false);

     

       7
        
       

     

       8
       +
             source((. signal) =>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       9
        
               switch (signal) {

     

       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)

     

       30
        
               }

     

       31
       +
             );

     

       32
       +
           })

     

       33
       +
         );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

+12 -9

src/operators/wonka_operator_onPush.re

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       -
       let onPush = f => curry(source => curry(sink => {

     

       4
       -
         source((.signal) => {

     

       5
       -
           switch (signal) {

     

       6
       -
           | Push(x) => f(.x)

     

       7
       -
           | _ => ()

     

       8
       -
           };

     

       0
        
       
     

       0
        
       
     

       9
        
       

     

       10
       -
           sink(.signal);

     

       11
       -
         });

     

       12
       -
       }));

     

       0
        
       
     

       13
        
       

     

       14
        
       let tap = onPush;

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       +
       let onPush = f =>

     

       4
       +
         curry(source =>

     

       5
       +
           curry(sink =>

     

       6
       +
             source((. signal) => {

     

       7
       +
               switch (signal) {

     

       8
       +
               | Push(x) => f(. x)

     

       9
       +
               | _ => ()

     

       10
       +
               };

     

       11
        
       

     

       12
       +
               sink(. signal);

     

       13
       +
             })

     

       14
       +
           )

     

       15
       +
         );

     

       16
        
       

     

       17
        
       let tap = onPush;

+13 -11

src/operators/wonka_operator_onStart.re

···

       1
        
       open Wonka_types;

     

       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
       -
       }));

     

       0
        
       
     

       0

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       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

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       -
       let scan = (f, seed) => curry(source => curry(sink => {

     

       4
       -
         let acc = ref(seed);

     

       0
        
       
     

       0
        
       
     

       5
        
       

     

       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
       -
       }));

     

       0
        
       
     

       0

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       +
       let scan = (f, seed) =>

     

       4
       +
         curry(source =>

     

       5
       +
           curry(sink => {

     

       6
       +
             let acc = ref(seed);

     

       7
        
       

     

       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
       +
         );

+26 -27

src/operators/wonka_operator_share.re

···

       3
        
       

     

       4
        
       type shareStateT('a) = {

     

       5
        
         mutable sinks: Rebel.Array.t(sinkT('a)),

     

       6
       -
         mutable talkback: (.talkbackT) => unit,

     

       7
       -
         mutable gotSignal: bool

     

       8
        
       };

     

       9
        
       

     

       10
        
       let share = source => {

     

       11
        
         let state = {

     

       12
        
           sinks: Rebel.Array.makeEmpty(),

     

       13
        
           talkback: talkbackPlaceholder,

     

       14
       -
           gotSignal: false

     

       15
        
         };

     

       16
        
       

     

       17
        
         sink => {

     

       18
        
           state.sinks = Rebel.Array.append(state.sinks, sink);

     

       19
        
       

     

       20
        
           if (Rebel.Array.size(state.sinks) === 1) {

     

       21
       -
             source((.signal) => {

     

       22
        
               switch (signal) {

     

       23
       -
               | Push(_) => {

     

       24
        
                 state.gotSignal = false;

     

       25
       -
                 Rebel.Array.forEach(state.sinks, sink => sink(.signal));

     

       26
       -
               }

     

       27
        
               | Start(x) => state.talkback = x

     

       28
       -
               | End => {

     

       29
       -
                 Rebel.Array.forEach(state.sinks, sink => sink(.End));

     

       30
        
                 state.sinks = Rebel.Array.makeEmpty();

     

       31
        
               }

     

       32
       -
               }

     

       33
       -
             });

     

       34
        
           };

     

       35
        
       

     

       36
       -
           sink(.Start((.signal) => {

     

       37
       -
             switch (signal) {

     

       38
       -
             | Close => {

     

       39
       -
               state.sinks = Rebel.Array.filter(state.sinks, x => x !== sink);

     

       40
       -
               if (Rebel.Array.size(state.sinks) === 0) {

     

       41
       -
                 state.talkback(.Close);

     

       42
       -
               };

     

       43
       -
             }

     

       44
       -
             | Pull when !state.gotSignal => {

     

       45
       -
               state.gotSignal = true;

     

       46
       -
               state.talkback(.signal);

     

       47
       -
             }

     

       48
       -
             | Pull => ()

     

       49
       -
             }

     

       50
       -
           }));

     

       51
       -
         }

     

       0
        
       
     

       52
        
       };

···

       3
        
       

     

       4
        
       type shareStateT('a) = {

     

       5
        
         mutable sinks: Rebel.Array.t(sinkT('a)),

     

       6
       +
         mutable talkback: (. talkbackT) => unit,

     

       7
       +
         mutable gotSignal: bool,

     

       8
        
       };

     

       9
        
       

     

       10
        
       let share = source => {

     

       11
        
         let state = {

     

       12
        
           sinks: Rebel.Array.makeEmpty(),

     

       13
        
           talkback: talkbackPlaceholder,

     

       14
       +
           gotSignal: false,

     

       15
        
         };

     

       16
        
       

     

       17
        
         sink => {

     

       18
        
           state.sinks = Rebel.Array.append(state.sinks, sink);

     

       19
        
       

     

       20
        
           if (Rebel.Array.size(state.sinks) === 1) {

     

       21
       +
             source((. signal) =>

     

       22
        
               switch (signal) {

     

       23
       +
               | Push(_) =>

     

       24
        
                 state.gotSignal = false;

     

       25
       +
                 Rebel.Array.forEach(state.sinks, sink => sink(. signal));

     

       0
        
       
     

       26
        
               | Start(x) => state.talkback = x

     

       27
       +
               | End =>

     

       28
       +
                 Rebel.Array.forEach(state.sinks, sink => sink(. End));

     

       29
        
                 state.sinks = Rebel.Array.makeEmpty();

     

       30
        
               }

     

       31
       +
             );

     

       0
        
       
     

       32
        
           };

     

       33
        
       

     

       34
       +
           sink(.

     

       35
       +
             Start(

     

       36
       +
               (. signal) =>

     

       37
       +
                 switch (signal) {

     

       38
       +
                 | Close =>

     

       39
       +
                   state.sinks = Rebel.Array.filter(state.sinks, x => x !== sink);

     

       40
       +
                   if (Rebel.Array.size(state.sinks) === 0) {

     

       41
       +
                     state.talkback(. Close);

     

       42
       +
                   };

     

       43
       +
                 | Pull when !state.gotSignal =>

     

       44
       +
                   state.gotSignal = true;

     

       45
       +
                   state.talkback(. signal);

     

       46
       +
                 | Pull => ()

     

       47
       +
                 },

     

       48
       +
             ),

     

       49
       +
           );

     

       50
       +
         };

     

       51
        
       };

+14 -12

src/operators/wonka_operator_skip.re

···

       1
        
       open Wonka_types;

     

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
       -
       let skip = wait => curry(source => curry(sink => {

     

       5
       -
         let rest = ref(wait);

     

       0
        
       
     

       0
        
       
     

       6
        
       

     

       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
       -
       }));

···

       1
        
       open Wonka_types;

     

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
       +
       let skip = wait =>

     

       5
       +
         curry(source =>

     

       6
       +
           curry(sink => {

     

       7
       +
             let rest = ref(wait);

     

       8
        
       

     

       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

···

       5
        
         mutable skip: bool,

     

       6
        
         mutable ended: bool,

     

       7
        
         mutable gotSignal: bool,

     

       8
       -
         mutable sourceTalkback: (.talkbackT) => unit,

     

       9
       -
         mutable notifierTalkback: (.talkbackT) => unit

     

       10
        
       };

     

       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
       -
         };

     

       0
        
       
     

       0
        
       
     

       20
        
       

     

       21
       -
         source((.signal) => {

     

       22
       -
           switch (signal) {

     

       23
       -
           | Start(tb) => {

     

       24
       -
             state.sourceTalkback = tb;

     

       25
       -
       

     

       26
       -
             notifier((.signal) => {

     

       27
        
               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 => ()

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       38
        
               }

     

       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
       -
         });

     

       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
       -
       }));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       5
        
         mutable skip: bool,

     

       6
        
         mutable ended: bool,

     

       7
        
         mutable gotSignal: bool,

     

       8
       +
         mutable sourceTalkback: (. talkbackT) => unit,

     

       9
       +
         mutable notifierTalkback: (. talkbackT) => unit,

     

       10
        
       };

     

       11
        
       

     

       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
       +
             };

     

       22
        
       

     

       23
       +
             source((. signal) =>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       24
        
               switch (signal) {

     

       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);

     

       52
        
               }

     

       53
       +
             );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       54
        
       

     

       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

···

       1
        
       open Wonka_types;

     

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
       -
       let skipWhile = f => curry(source => curry(sink => {

     

       5
       -
         let skip = ref(true);

     

       0
        
       
     

       0
        
       
     

       6
        
       

     

       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
       -
       }));

···

       1
        
       open Wonka_types;

     

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
       +
       let skipWhile = f =>

     

       5
       +
         curry(source =>

     

       6
       +
           curry(sink => {

     

       7
       +
             let skip = ref(true);

     

       8
        
       

     

       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

···

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
        
       type switchMapStateT('a) = {

     

       5
       -
         mutable outerTalkback: (.talkbackT) => unit,

     

       6
       -
         mutable innerTalkback: (.talkbackT) => unit,

     

       7
        
         mutable innerActive: bool,

     

       8
        
         mutable closed: bool,

     

       9
       -
         mutable ended: bool

     

       10
        
       };

     

       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
       -
         };

     

       0
        
       
     

       0
        
       
     

       20
        
       

     

       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
       -
           });

     

       41
        
       

     

       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
       -
         });

     

       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
       -
       }));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       80
        
       

     

       81
       -
       let switchAll = source => switchMap((.x) => x, source);

···

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
        
       type switchMapStateT('a) = {

     

       5
       +
         mutable outerTalkback: (. talkbackT) => unit,

     

       6
       +
         mutable innerTalkback: (. talkbackT) => unit,

     

       7
        
         mutable innerActive: bool,

     

       8
        
         mutable closed: bool,

     

       9
       +
         mutable ended: bool,

     

       10
        
       };

     

       11
        
       

     

       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
       +
             };

     

       22
        
       

     

       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
       +
               );

     

       0
        
       
     

       42
        
       

     

       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
       +
             );

     

       0
        
       
     

       64
        
       

     

       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
       +
         );

     

       83
        
       

     

       84
       +
       let switchAll = source => switchMap((. x) => x, source);

+37 -37

src/operators/wonka_operator_take.re

···

       3
        
       

     

       4
        
       type takeStateT = {

     

       5
        
         mutable taken: int,

     

       6
       -
         mutable talkback: (.talkbackT) => unit

     

       7
        
       };

     

       8
        
       

     

       9
       -
       let take = max => curry(source => curry(sink => {

     

       10
       -
         let state: takeStateT = {

     

       11
       -
           taken: 0,

     

       12
       -
           talkback: talkbackPlaceholder

     

       13
       -
         };

     

       14
        
       

     

       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);

     

       21
        
       

     

       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
       -
         });

     

       35
        
       

     

       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
       -
       }));

     

       0
        
       
     

       0
        
       
     

       0

···

       3
        
       

     

       4
        
       type takeStateT = {

     

       5
        
         mutable taken: int,

     

       6
       +
         mutable talkback: (. talkbackT) => unit,

     

       7
        
       };

     

       8
        
       

     

       9
       +
       let take = max =>

     

       10
       +
         curry(source =>

     

       11
       +
           curry(sink => {

     

       12
       +
             let state: takeStateT = {taken: 0, talkback: talkbackPlaceholder};

     

       0
        
       
     

       13
        
       

     

       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);

     

       20
        
       

     

       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
       +
             );

     

       0
        
       
     

       0
        
       
     

       32
        
       

     

       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

···

       1
        
       open Wonka_types;

     

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
       -
       let takeLast = max => curry(source => curry(sink => {

     

       5
       -
         open Rebel;

     

       6
       -
         let queue = MutableQueue.make();

     

       0
        
       
     

       0
        
       
     

       7
        
       

     

       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
       -
             };

     

       16
        
       

     

       17
       -
             MutableQueue.add(queue, x);

     

       18
       -
             talkback(.Pull);

     

       19
       -
           }

     

       20
       -
           | End => makeTrampoline(sink, (.) => MutableQueue.pop(queue))

     

       21
       -
           }

     

       22
       -
         });

     

       23
       -
       }));

···

       1
        
       open Wonka_types;

     

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
       +
       let takeLast = max =>

     

       5
       +
         curry(source =>

     

       6
       +
           curry(sink => {

     

       7
       +
             open Rebel;

     

       8
       +
             let queue = MutableQueue.make();

     

       9
        
       

     

       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
       +
                 };

     

       18
        
       

     

       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

···

       3
        
       

     

       4
        
       type takeUntilStateT = {

     

       5
        
         mutable ended: bool,

     

       6
       -
         mutable sourceTalkback: (.talkbackT) => unit,

     

       7
       -
         mutable notifierTalkback: (.talkbackT) => unit

     

       8
        
       };

     

       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;

     

       21
        
       

     

       22
       -
             notifier((.signal) => {

     

       23
        
               switch (signal) {

     

       24
       -
               | Start(innerTb) => {

     

       25
       -
                 state.notifierTalkback = innerTb;

     

       26
       -
                 innerTb(.Pull);

     

       27
       -
               }

     

       28
       -
               | Push(_) => {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       29
        
                 state.ended = true;

     

       30
       -
                 state.notifierTalkback(.Close);

     

       31
       -
                 state.sourceTalkback(.Close);

     

       32
       -
                 sink(.End);

     

       33
       -
               }

     

       34
        
               | End => ()

     

       0
        
       
     

       0
        
       
     

       35
        
               }

     

       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
       -
         });

     

       48
        
       

     

       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
       -
       }));

     

       0
        
       
     

       0
        
       
     

       0

···

       3
        
       

     

       4
        
       type takeUntilStateT = {

     

       5
        
         mutable ended: bool,

     

       6
       +
         mutable sourceTalkback: (. talkbackT) => unit,

     

       7
       +
         mutable notifierTalkback: (. talkbackT) => unit,

     

       8
        
       };

     

       9
        
       

     

       10
       +
       let takeUntil = notifier =>

     

       11
       +
         curry(source =>

     

       12
       +
           curry(sink => {

     

       13
       +
             let state: takeUntilStateT = {

     

       14
       +
               ended: false,

     

       15
       +
               sourceTalkback: talkbackPlaceholder,

     

       16
       +
               notifierTalkback: talkbackPlaceholder,

     

       17
       +
             };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       18
        
       

     

       19
       +
             source((. signal) =>

     

       20
        
               switch (signal) {

     

       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);

     

       39
        
                 state.ended = true;

     

       40
       +
                 sink(. End);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       41
        
               | End => ()

     

       42
       +
               | Push(_) when !state.ended => sink(. signal)

     

       43
       +
               | Push(_) => ()

     

       44
        
               }

     

       45
       +
             );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       46
        
       

     

       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

···

       1
        
       open Wonka_types;

     

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
       -
       let takeWhile = f => curry(source => curry(sink => {

     

       5
       -
         let ended = ref(false);

     

       6
       -
         let talkback = ref(talkbackPlaceholder);

     

       0
        
       
     

       0
        
       
     

       7
        
       

     

       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
       -
         });

     

       31
        
       

     

       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
       -
       }));

     

       0
        
       
     

       0
        
       
     

       0

···

       1
        
       open Wonka_types;

     

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
       +
       let takeWhile = f =>

     

       5
       +
         curry(source =>

     

       6
       +
           curry(sink => {

     

       7
       +
             let ended = ref(false);

     

       8
       +
             let talkback = ref(talkbackPlaceholder);

     

       9
        
       

     

       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
       +
             );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       30
        
       

     

       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

···

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
        
       type publishStateT = {

     

       5
       -
         mutable talkback: (.talkbackT) => unit,

     

       6
       -
         mutable ended: bool

     

       7
        
       };

     

       8
        
       

     

       9
        
       let publish = source => {

     

       10
       -
         let state: publishStateT = {

     

       11
       -
           talkback: talkbackPlaceholder,

     

       12
       -
           ended: false

     

       13
       -
         };

     

       14
        
       

     

       15
       -
         source((.signal) => {

     

       16
        
           switch (signal) {

     

       17
       -
           | Start(x) => {

     

       18
        
             state.talkback = x;

     

       19
       -
             x(.Pull);

     

       20
       -
           }

     

       21
       -
           | Push(_) => if (!state.ended) state.talkback(.Pull);

     

       22
       -
           | End => state.ended = true;

     

       0
        
       
     

       0
        
       
     

       23
        
           }

     

       24
       -
         });

     

       25
        
       

     

       26
        
         {

     

       27
        
           unsubscribe: () =>

     

       28
        
             if (!state.ended) {

     

       29
        
               state.ended = true;

     

       30
       -
               state.talkback(.Close);

     

       31
       -
             }

     

       32
       -
         }

     

       33
        
       };

···

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
        
       type publishStateT = {

     

       5
       +
         mutable talkback: (. talkbackT) => unit,

     

       6
       +
         mutable ended: bool,

     

       7
        
       };

     

       8
        
       

     

       9
        
       let publish = source => {

     

       10
       +
         let state: publishStateT = {talkback: talkbackPlaceholder, ended: false};

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       11
        
       

     

       12
       +
         source((. signal) =>

     

       13
        
           switch (signal) {

     

       14
       +
           | Start(x) =>

     

       15
        
             state.talkback = x;

     

       16
       +
             x(. Pull);

     

       17
       +
           | Push(_) =>

     

       18
       +
             if (!state.ended) {

     

       19
       +
               state.talkback(. Pull);

     

       20
       +
             }

     

       21
       +
           | End => state.ended = true

     

       22
        
           }

     

       23
       +
         );

     

       24
        
       

     

       25
        
         {

     

       26
        
           unsubscribe: () =>

     

       27
        
             if (!state.ended) {

     

       28
        
               state.ended = true;

     

       29
       +
               state.talkback(. Close);

     

       30
       +
             },

     

       31
       +
         };

     

       32
        
       };

+29 -32

src/sinks/wonka_sink_subscribe.re

···

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
        
       type subscribeStateT = {

     

       5
       -
         mutable talkback: (.talkbackT) => unit,

     

       6
       -
         mutable ended: bool

     

       7
        
       };

     

       8
        
       

     

       9
       -
       let subscribe = f => curry(source => {

     

       10
       -
         let state: subscribeStateT = {

     

       11
       -
           talkback: talkbackPlaceholder,

     

       12
       -
           ended: false

     

       13
       -
         };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
       

     

       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
       -
           }

     

       28
        
         });

     

       29
        
       

     

       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
       -
       });

···

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
        
       type subscribeStateT = {

     

       5
       +
         mutable talkback: (. talkbackT) => unit,

     

       6
       +
         mutable ended: bool,

     

       7
        
       };

     

       8
        
       

     

       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
       +
           );

     

       28
        
       

     

       29
       +
           {

     

       30
       +
             unsubscribe: () =>

     

       31
       +
               if (!state.ended) {

     

       32
       +
                 state.ended = true;

     

       33
       +
                 state.talkback(. Close);

     

       34
       +
               },

     

       35
       +
           };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       36
        
         });

     

       37
        
       

     

       38
       +
       let forEach = f => curry(source => ignore(subscribe(f, source)));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

+31 -33

src/sources/wonka_source_fromArray.re

···

       4
        
         mutable index: int,

     

       5
        
         mutable ended: bool,

     

       6
        
         mutable looping: bool,

     

       7
       -
         mutable pull: bool

     

       8
        
       };

     

       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
       -
         };

     

       18
        
       

     

       19
       -
         sink(.Start((.signal) => {

     

       20
       -
           switch (signal, state.looping) {

     

       21
       -
           | (Pull, false) => {

     

       22
       -
             state.pull = true;

     

       23
       -
             state.looping = true;

     

       0
        
       
     

       0
        
       
     

       24
        
       

     

       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
       -
             };

     

       37
        
       

     

       38
       -
             state.looping = false;

     

       39
       -
           }

     

       40
       -
           | (Pull, true) => state.pull = true

     

       41
       -
           | (Close, _) => state.ended = true

     

       42
       -
           }

     

       43
       -
         }));

     

       44
       -
       });

···

       4
        
         mutable index: int,

     

       5
        
         mutable ended: bool,

     

       6
        
         mutable looping: bool,

     

       7
       +
         mutable pull: bool,

     

       8
        
       };

     

       9
        
       

     

       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};

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
       

     

       15
       +
           sink(.

     

       16
       +
             Start(

     

       17
       +
               (. signal) =>

     

       18
       +
                 switch (signal, state.looping) {

     

       19
       +
                 | (Pull, false) =>

     

       20
       +
                   state.pull = true;

     

       21
       +
                   state.looping = true;

     

       22
        
       

     

       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
       +
                   };

     

       35
        
       

     

       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

···

       4
        
         mutable value: 'a,

     

       5
        
         mutable ended: bool,

     

       6
        
         mutable looping: bool,

     

       7
       -
         mutable pull: bool

     

       8
        
       };

     

       9
        
       

     

       10
       -
       let fromList = ls => curry(sink => {

     

       11
       -
         let state = {

     

       12
       -
           value: ls,

     

       13
       -
           ended: false,

     

       14
       -
           looping: false,

     

       15
       -
           pull: false

     

       16
       -
         };

     

       17
        
       

     

       18
       -
         sink(.Start((.signal) => {

     

       19
       -
           switch (signal, state.looping) {

     

       20
       -
           | (Pull, false) => {

     

       21
       -
             state.pull = true;

     

       22
       -
             state.looping = true;

     

       0
        
       
     

       0
        
       
     

       23
        
       

     

       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
       -
             };

     

       37
        
       

     

       38
       -
             state.looping = false;

     

       39
       -
           }

     

       40
       -
           | (Pull, true) => state.pull = true

     

       41
       -
           | (Close, _) => state.ended = true

     

       42
       -
           }

     

       43
       -
         }));

     

       44
       -
       });

···

       4
        
         mutable value: 'a,

     

       5
        
         mutable ended: bool,

     

       6
        
         mutable looping: bool,

     

       7
       +
         mutable pull: bool,

     

       8
        
       };

     

       9
        
       

     

       10
       +
       let fromList = ls =>

     

       11
       +
         curry(sink => {

     

       12
       +
           let state = {value: ls, ended: false, looping: false, pull: false};

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
       

     

       14
       +
           sink(.

     

       15
       +
             Start(

     

       16
       +
               (. signal) =>

     

       17
       +
                 switch (signal, state.looping) {

     

       18
       +
                 | (Pull, false) =>

     

       19
       +
                   state.pull = true;

     

       20
       +
                   state.looping = true;

     

       21
        
       

     

       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
       +
                   };

     

       0
        
       
     

       0
        
       
     

       33
        
       

     

       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

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       -
       let fromValue = x => curry(sink => {

     

       4
       -
         let ended = ref(false);

     

       0
        
       
     

       5
        
       

     

       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
       -
       });

     

       0
        
       
     

       0

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       +
       let fromValue = x =>

     

       4
       +
         curry(sink => {

     

       5
       +
           let ended = ref(false);

     

       6
        
       

     

       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

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       -
       let make = f => curry(sink => {

     

       4
       -
         let teardown = ref((.) => ());

     

       0
        
       
     

       5
        
       

     

       6
       -
         sink(.Start((.signal) => {

     

       7
       -
           switch (signal) {

     

       8
       -
           | Close => teardown^(.)

     

       9
       -
           | Pull => ()

     

       10
       -
           }

     

       11
       -
         }));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       12
        
       

     

       13
       -
         teardown := f(.{

     

       14
       -
           next: value => sink(.Push(value)),

     

       15
       -
           complete: () => sink(.End)

     

       0
        
       
     

       0
        
       
     

       16
        
         });

     

       17
       -
       });

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       +
       let make = f =>

     

       4
       +
         curry(sink => {

     

       5
       +
           let teardown = ref((.) => ());

     

       6
        
       

     

       7
       +
           sink(.

     

       8
       +
             Start(

     

       9
       +
               (. signal) =>

     

       10
       +
                 switch (signal) {

     

       11
       +
                 | Close => teardown^(.)

     

       12
       +
                 | Pull => ()

     

       13
       +
                 },

     

       14
       +
             ),

     

       15
       +
           );

     

       16
        
       

     

       17
       +
           teardown :=

     

       18
       +
             f(. {

     

       19
       +
               next: value => sink(. Push(value)),

     

       20
       +
               complete: () => sink(. End),

     

       21
       +
             });

     

       22
        
         });

     

       0

+12 -9

src/sources/wonka_source_makeSubject.re

···

       2
        
       

     

       3
        
       type subjectState('a) = {

     

       4
        
         mutable sinks: Rebel.Array.t(sinkT('a)),

     

       5
       -
         mutable ended: bool

     

       6
        
       };

     

       7
        
       

     

       8
        
       let makeSubject = () => {

     
···

       13
        
       

     

       14
        
         let source = sink => {

     

       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
       -
           }));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       21
        
         };

     

       22
        
       

     

       23
        
         let next = value =>

     

       24
        
           if (!state.ended) {

     

       25
       -
             Rebel.Array.forEach(state.sinks, sink => sink(.Push(value)));

     

       26
        
           };

     

       27
        
       

     

       28
        
         let complete = () =>

     

       29
        
           if (!state.ended) {

     

       30
        
             state.ended = true;

     

       31
       -
             Rebel.Array.forEach(state.sinks, sink => sink(.End));

     

       32
        
           };

     

       33
        
       

     

       34
       -
         { source, next, complete }

     

       35
        
       };

···

       2
        
       

     

       3
        
       type subjectState('a) = {

     

       4
        
         mutable sinks: Rebel.Array.t(sinkT('a)),

     

       5
       +
         mutable ended: bool,

     

       6
        
       };

     

       7
        
       

     

       8
        
       let makeSubject = () => {

     
···

       13
        
       

     

       14
        
         let source = sink => {

     

       15
        
           state.sinks = Rebel.Array.append(state.sinks, sink);

     

       16
       +
           sink(.

     

       17
       +
             Start(

     

       18
       +
               (. signal) =>

     

       19
       +
                 if (signal === Close) {

     

       20
       +
                   state.sinks = Rebel.Array.filter(state.sinks, x => x !== sink);

     

       21
       +
                 },

     

       22
       +
             ),

     

       23
       +
           );

     

       24
        
         };

     

       25
        
       

     

       26
        
         let next = value =>

     

       27
        
           if (!state.ended) {

     

       28
       +
             Rebel.Array.forEach(state.sinks, sink => sink(. Push(value)));

     

       29
        
           };

     

       30
        
       

     

       31
        
         let complete = () =>

     

       32
        
           if (!state.ended) {

     

       33
        
             state.ended = true;

     

       34
       +
             Rebel.Array.forEach(state.sinks, sink => sink(. End));

     

       35
        
           };

     

       36
        
       

     

       37
       +
         {source, next, complete};

     

       38
        
       };

+3 -3

src/sources/wonka_source_primitives.re

···

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
        
       let empty = sink => {

     

       5
       -
         sink(.Start(talkbackPlaceholder));

     

       6
       -
         sink(.End);

     

       7
        
       };

     

       8
        
       

     

       9
        
       let never = sink => {

     

       10
       -
         sink(.Start(talkbackPlaceholder));

     

       11
        
       };

···

       2
        
       open Wonka_helpers;

     

       3
        
       

     

       4
        
       let empty = sink => {

     

       5
       +
         sink(. Start(talkbackPlaceholder));

     

       6
       +
         sink(. End);

     

       7
        
       };

     

       8
        
       

     

       9
        
       let never = sink => {

     

       10
       +
         sink(. Start(talkbackPlaceholder));

     

       11
        
       };

+49 -40

src/web/wonka_operator_debounce.re

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       -
       let debounce = f => curry(source => curry(sink => {

     

       4
       -
         let gotEndSignal = ref(false);

     

       5
       -
         let id: ref(option(Js.Global.timeoutId)) = ref(None);

     

       0
        
       
     

       0
        
       
     

       6
        
       

     

       7
       -
         let clearTimeout = () =>

     

       8
       -
           switch (id^) {

     

       9
       -
           | Some(timeoutId) => {

     

       10
       -
             id := None;

     

       11
       -
             Js.Global.clearTimeout(timeoutId);

     

       12
       -
           }

     

       13
       -
           | None => ()

     

       14
       -
           };

     

       15
        
       

     

       16
       -
         source((.signal) => {

     

       17
       -
           switch (signal) {

     

       18
       -
           | Start(tb) => {

     

       19
       -
             sink(.Start((.signal) => {

     

       20
        
               switch (signal) {

     

       21
       -
               | Close => {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       22
        
                 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;

     

       39
        
       

     

       40
       -
             switch (id^) {

     

       41
       -
             | None => sink(.End)

     

       42
       -
             | _ => ()

     

       43
       -
             };

     

       44
       -
           }

     

       45
       -
           }

     

       46
       -
         });

     

       47
       -
       }));

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       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);

     

       8
        
       

     

       9
       +
             let clearTimeout = () =>

     

       10
       +
               switch (id^) {

     

       11
       +
               | Some(timeoutId) =>

     

       12
       +
                 id := None;

     

       13
       +
                 Js.Global.clearTimeout(timeoutId);

     

       14
       +
               | None => ()

     

       15
       +
               };

     

       0
        
       
     

       16
        
       

     

       17
       +
             source((. signal) =>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       18
        
               switch (signal) {

     

       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) =>

     

       32
        
                 clearTimeout();

     

       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;

     

       0
        
       
     

       48
        
       

     

       49
       +
                 switch (id^) {

     

       50
       +
                 | None => sink(. End)

     

       51
       +
                 | _ => ()

     

       52
       +
                 };

     

       53
       +
               }

     

       54
       +
             );

     

       55
       +
           })

     

       56
       +
         );

+47 -36

src/web/wonka_operator_delay.re

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
        
       type delayStateT = {

     

       4
       -
         mutable talkback: (.talkbackT) => unit,

     

       5
        
         mutable active: int,

     

       6
       -
         mutable gotEndSignal: bool

     

       7
        
       };

     

       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
       -
         };

     

       0
        
       
     

       0
        
       
     

       15
        
       

     

       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
       -
               };

     

       0
        
       
     

       0
        
       
     

       27
        
       

     

       28
       -
               sink(.signal);

     

       29
       -
             }, wait));

     

       30
       -
           }

     

       31
       -
           | _ => ()

     

       32
       -
           }

     

       33
       -
         });

     

       0
        
       
     

       0
        
       
     

       34
        
       

     

       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
       -
       }));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
        
       type delayStateT = {

     

       4
       +
         mutable talkback: (. talkbackT) => unit,

     

       5
        
         mutable active: int,

     

       6
       +
         mutable gotEndSignal: bool,

     

       7
        
       };

     

       8
        
       

     

       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
       +
             };

     

       17
        
       

     

       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
       +
                       };

     

       31
        
       

     

       32
       +
                       sink(. signal);

     

       33
       +
                     },

     

       34
       +
                     wait,

     

       35
       +
                   ),

     

       36
       +
                 );

     

       37
       +
               | _ => ()

     

       38
       +
               }

     

       39
       +
             );

     

       40
        
       

     

       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

···

       1
        
       open Wonka_types;

     

       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);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       10
        
       

     

       11
       -
         sink(.Start((.signal) => {

     

       12
       -
           switch (signal) {

     

       13
       -
           | Close => Js.Global.clearInterval(id)

     

       14
       -
           | _ => ()

     

       15
       -
           }

     

       16
       -
         }));

     

       17
       -
       });

     

       0
        
       
     

       0
        
       
     

       0

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       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
       +
             );

     

       15
        
       

     

       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

···

       3
        
       type sampleStateT('a) = {

     

       4
        
         mutable ended: bool,

     

       5
        
         mutable value: option('a),

     

       6
       -
         mutable sourceTalkback: (.talkbackT) => unit,

     

       7
       -
         mutable notifierTalkback: (.talkbackT) => unit

     

       8
        
       };

     

       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
       -
         };

     

       0
        
       
     

       0
        
       
     

       17
        
       

     

       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
       -
         });

     

       29
        
       

     

       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
       -
         });

     

       45
        
       

     

       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
       -
       }));

     

       0
        
       
     

       0

···

       3
        
       type sampleStateT('a) = {

     

       4
        
         mutable ended: bool,

     

       5
        
         mutable value: option('a),

     

       6
       +
         mutable sourceTalkback: (. talkbackT) => unit,

     

       7
       +
         mutable notifierTalkback: (. talkbackT) => unit,

     

       8
        
       };

     

       9
        
       

     

       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
       +
             };

     

       19
        
       

     

       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
       +
             );

     

       0
        
       
     

       30
        
       

     

       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
       +
             );

     

       0
        
       
     

       0
        
       
     

       44
        
       

     

       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

···

       1
        
       open Wonka_types;

     

       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
       -
           };

     

       0
        
       
     

       0
        
       
     

       11
        
       

     

       12
       -
         source((.signal) => {

     

       13
       -
           switch (signal) {

     

       14
       -
           | Start(tb) => {

     

       15
       -
             sink(.Start((.signal) => {

     

       16
        
               switch (signal) {

     

       17
       -
               | Close => {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       18
        
                 clearTimeout();

     

       19
       -
                 tb(.Close);

     

       20
       -
               }

     

       21
       -
               | _ => tb(.signal)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       22
        
               }

     

       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
       -
       }));

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       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
       +
               };

     

       13
        
       

     

       14
       +
             source((. signal) =>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       15
        
               switch (signal) {

     

       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 =>

     

       29
        
                 clearTimeout();

     

       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(_) => ()

     

       46
        
               }

     

       47
       +
             );

     

       48
       +
           })

     

       49
       +
         );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

+11 -11

src/web/wonka_sink_toPromise.re

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       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
       -
         });

     

       15
        
       };

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
        
       let toPromise = source => {

     

       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
        
       };

+16 -19

src/web/wonka_source_fromDomEvent.re

···

       1
        
       open Wonka_types;

     

       2
        
       open Wonka_source_fromListener;

     

       3
        
       

     

       4
       -
       let fromDomEvent = (element, event) => curry(sink => {

     

       5
       -
         let addEventListener: (

     

       6
       -
           Dom.element,

     

       7
       -
           string,

     

       8
       -
           (Dom.event) => unit

     

       9
       -
         ) => unit = [%raw {|

     

       10
        
           function (element, event, handler) {

     

       11
        
             element.addEventListener(event, handler);

     

       12
        
           }

     

       13
       -
         |}];

     

       0
        
       
     

       14
        
       

     

       15
       -
         let removeEventListener: (

     

       16
       -
           Dom.element,

     

       17
       -
           string,

     

       18
       -
           (Dom.event) => unit

     

       19
       -
         ) => unit = [%raw {|

     

       20
        
           function (element, event, handler) {

     

       21
        
             element.removeEventListener(event, handler);

     

       22
        
           }

     

       23
       -
         |}];

     

       0
        
       
     

       24
        
       

     

       25
       -
         fromListener(

     

       26
       -
           handler => addEventListener(element, event, handler),

     

       27
       -
           handler => removeEventListener(element, event, handler),

     

       28
       -
           sink

     

       29
       -
         )

     

       30
       -
       });

···

       1
        
       open Wonka_types;

     

       2
        
       open Wonka_source_fromListener;

     

       3
        
       

     

       4
       +
       let fromDomEvent = (element, event) =>

     

       5
       +
         curry(sink => {

     

       6
       +
           let addEventListener: (Dom.element, string, Dom.event => unit) => unit = [%raw

     

       7
       +
             {|

     

       0
        
       
     

       0
        
       
     

       8
        
           function (element, event, handler) {

     

       9
        
             element.addEventListener(event, handler);

     

       10
        
           }

     

       11
       +
         |}

     

       12
       +
           ];

     

       13
        
       

     

       14
       +
           let removeEventListener: (Dom.element, string, Dom.event => unit) => unit = [%raw

     

       15
       +
             {|

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       16
        
           function (element, event, handler) {

     

       17
        
             element.removeEventListener(event, handler);

     

       18
        
           }

     

       19
       +
         |}

     

       20
       +
           ];

     

       21
        
       

     

       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

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       -
       let fromListener = (addListener, removeListener) => curry(sink => {

     

       4
       -
         let handler = event => sink(.Push(event));

     

       0
        
       
     

       5
        
       

     

       6
       -
         sink(.Start((.signal) => {

     

       7
       -
           switch (signal) {

     

       8
       -
           | Close => removeListener(handler)

     

       9
       -
           | _ => ()

     

       10
       -
           }

     

       11
       -
         }));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       12
        
       

     

       13
       -
         addListener(handler);

     

       14
       -
       });

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       +
       let fromListener = (addListener, removeListener) =>

     

       4
       +
         curry(sink => {

     

       5
       +
           let handler = event => sink(. Push(event));

     

       6
        
       

     

       7
       +
           sink(.

     

       8
       +
             Start(

     

       9
       +
               (. signal) =>

     

       10
       +
                 switch (signal) {

     

       11
       +
                 | Close => removeListener(handler)

     

       12
       +
                 | _ => ()

     

       13
       +
                 },

     

       14
       +
             ),

     

       15
       +
           );

     

       16
        
       

     

       17
       +
           addListener(handler);

     

       18
       +
         });

+25 -16

src/web/wonka_source_fromPromise.re

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       -
       let fromPromise = promise => curry(sink => {

     

       4
       -
         let ended = ref(false);

     

       0
        
       
     

       5
        
       

     

       6
       -
         ignore(Js.Promise.then_(value => {

     

       7
       -
           if (!ended^) {

     

       8
       -
             sink(.Push(value));

     

       9
       -
             sink(.End);

     

       10
       -
           };

     

       0
        
       
     

       0
        
       
     

       11
        
       

     

       12
       -
           Js.Promise.resolve(())

     

       13
       -
         }, promise));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
       

     

       15
       -
         sink(.Start((.signal) => {

     

       16
       -
           switch (signal) {

     

       17
       -
           | Close => ended := true

     

       18
       -
           | _ => ()

     

       19
       -
           }

     

       20
       -
         }));

     

       21
       -
       });

     

       0
        
       
     

       0
        
       
     

       0

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       +
       let fromPromise = promise =>

     

       4
       +
         curry(sink => {

     

       5
       +
           let ended = ref(false);

     

       6
        
       

     

       7
       +
           ignore(

     

       8
       +
             Js.Promise.then_(

     

       9
       +
               value => {

     

       10
       +
                 if (! ended^) {

     

       11
       +
                   sink(. Push(value));

     

       12
       +
                   sink(. End);

     

       13
       +
                 };

     

       14
        
       

     

       15
       +
                 Js.Promise.resolve();

     

       16
       +
               },

     

       17
       +
               promise,

     

       18
       +
             ),

     

       19
       +
           );

     

       20
        
       

     

       21
       +
           sink(.

     

       22
       +
             Start(

     

       23
       +
               (. signal) =>

     

       24
       +
                 switch (signal) {

     

       25
       +
                 | Close => ended := true

     

       26
       +
                 | _ => ()

     

       27
       +
                 },

     

       28
       +
             ),

     

       29
       +
           );

     

       30
       +
         });

+31 -26

src/wonka_helpers.re

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       -
       let talkbackPlaceholder = (._: talkbackT) => ();

     

       4
        
       

     

       5
       -
       let captureTalkback = (

     

       6
       -
         source: sourceT('a),

     

       7
       -
         sinkWithTalkback: (.signalT('a), (.talkbackT) => unit) => unit

     

       8
       -
       ) => {

     

       0
        
       
     

       9
        
         let talkback = ref(talkbackPlaceholder);

     

       10
        
       

     

       11
       -
         source((.signal) => {

     

       12
        
           switch (signal) {

     

       13
        
           | Start(x) => talkback := x

     

       14
        
           | _ => ()

     

       15
        
           };

     

       16
        
       

     

       17
       -
           sinkWithTalkback(.signal, talkback^)

     

       18
        
         });

     

       19
        
       };

     

       20
        
       

     

       21
        
       type trampolineT = {

     

       22
        
         mutable exhausted: bool,

     

       23
        
         mutable inLoop: bool,

     

       24
       -
         mutable gotSignal: bool

     

       25
        
       };

     

       26
        
       

     

       27
       -
       let makeTrampoline = (sink: sinkT('a), f: (.unit) => option('a)) => {

     

       28
        
         let state: trampolineT = {

     

       29
        
           exhausted: false,

     

       30
        
           inLoop: false,

     

       31
       -
           gotSignal: false

     

       32
        
         };

     

       33
        
       

     

       34
        
         let loop = () => {

     

       35
        
           let rec explode = () =>

     

       36
        
             switch (f(.)) {

     

       37
       -
             | Some(x) => {

     

       38
        
               state.gotSignal = false;

     

       39
       -
               sink(.Push(x));

     

       40
       -
               if (state.gotSignal) explode();

     

       41
       -
             }

     

       42
       -
             | None => {

     

       0
        
       
     

       43
        
               state.exhausted = true;

     

       44
       -
               sink(.End)

     

       45
       -
             }

     

       46
        
             };

     

       47
        
       

     

       48
        
           state.inLoop = true;

     
···

       50
        
           state.inLoop = false;

     

       51
        
         };

     

       52
        
       

     

       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
       -
         }));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       62
        
       };

···

       1
        
       open Wonka_types;

     

       2
        
       

     

       3
       +
       let talkbackPlaceholder = (. _: talkbackT) => ();

     

       4
        
       

     

       5
       +
       let captureTalkback =

     

       6
       +
           (

     

       7
       +
             source: sourceT('a),

     

       8
       +
             sinkWithTalkback: (. signalT('a), (. talkbackT) => unit) => unit,

     

       9
       +
           ) => {

     

       10
        
         let talkback = ref(talkbackPlaceholder);

     

       11
        
       

     

       12
       +
         source((. signal) => {

     

       13
        
           switch (signal) {

     

       14
        
           | Start(x) => talkback := x

     

       15
        
           | _ => ()

     

       16
        
           };

     

       17
        
       

     

       18
       +
           sinkWithTalkback(. signal, talkback^);

     

       19
        
         });

     

       20
        
       };

     

       21
        
       

     

       22
        
       type trampolineT = {

     

       23
        
         mutable exhausted: bool,

     

       24
        
         mutable inLoop: bool,

     

       25
       +
         mutable gotSignal: bool,

     

       26
        
       };

     

       27
        
       

     

       28
       +
       let makeTrampoline = (sink: sinkT('a), f: (. unit) => option('a)) => {

     

       29
        
         let state: trampolineT = {

     

       30
        
           exhausted: false,

     

       31
        
           inLoop: false,

     

       32
       +
           gotSignal: false,

     

       33
        
         };

     

       34
        
       

     

       35
        
         let loop = () => {

     

       36
        
           let rec explode = () =>

     

       37
        
             switch (f(.)) {

     

       38
       +
             | Some(x) =>

     

       39
        
               state.gotSignal = false;

     

       40
       +
               sink(. Push(x));

     

       41
       +
               if (state.gotSignal) {

     

       42
       +
                 explode();

     

       43
       +
               };

     

       44
       +
             | None =>

     

       45
        
               state.exhausted = true;

     

       46
       +
               sink(. End);

     

       0
        
       
     

       47
        
             };

     

       48
        
       

     

       49
        
           state.inLoop = true;

     
···

       51
        
           state.inLoop = false;

     

       52
        
         };

     

       53
        
       

     

       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
       +
         );

     

       67
        
       };

+6 -8

src/wonka_types.re

···

       31
        
         | Close;

     

       32
        
       

     

       33
        
       type signalT('a) =

     

       34
       -
         | Start((.talkbackT) => unit)

     

       35
        
         | Push('a)

     

       36
        
         | End;

     

       37
        
       

     

       38
       -
       type sinkT('a) = (.signalT('a)) => unit;

     

       39
        
       type sourceT('a) = sinkT('a) => unit;

     

       40
        
       

     

       41
       -
       type teardownT = (.unit) => unit;

     

       42
        
       

     

       43
       -
       type subscriptionT = {

     

       44
       -
         unsubscribe: unit => unit

     

       45
       -
       };

     

       46
        
       

     

       47
        
       type observerT('a) = {

     

       48
        
         next: 'a => unit,

     

       49
       -
         complete: unit => unit

     

       50
        
       };

     

       51
        
       

     

       52
        
       type subjectT('a) = {

     

       53
        
         source: sourceT('a),

     

       54
        
         next: 'a => unit,

     

       55
       -
         complete: unit => unit

     

       56
        
       };

     

       57
        
       

     

       58
        
       /* Sinks and sources need to explicitly be their own callbacks;

···

       31
        
         | Close;

     

       32
        
       

     

       33
        
       type signalT('a) =

     

       34
       +
         | Start((. talkbackT) => unit)

     

       35
        
         | Push('a)

     

       36
        
         | End;

     

       37
        
       

     

       38
       +
       type sinkT('a) = (. signalT('a)) => unit;

     

       39
        
       type sourceT('a) = sinkT('a) => unit;

     

       40
        
       

     

       41
       +
       type teardownT = (. unit) => unit;

     

       42
        
       

     

       43
       +
       type subscriptionT = {unsubscribe: unit => unit};

     

       0
        
       
     

       0
        
       
     

       44
        
       

     

       45
        
       type observerT('a) = {

     

       46
        
         next: 'a => unit,

     

       47
       +
         complete: unit => unit,

     

       48
        
       };

     

       49
        
       

     

       50
        
       type subjectT('a) = {

     

       51
        
         source: sourceT('a),

     

       52
        
         next: 'a => unit,

     

       53
       +
         complete: unit => unit,

     

       54
        
       };

     

       55
        
       

     

       56
        
       /* Sinks and sources need to explicitly be their own callbacks;

+563 -10

yarn.lock

···

       156
        
           core-js "^2.5.7"

     

       157
        
           regenerator-runtime "^0.12.0"

     

       158
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       159
        
       "@babel/template@^7.1.0", "@babel/template@^7.1.2", "@babel/template@^7.2.2":

     

       160
        
         version "7.2.2"

     

       161
        
         resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.2.2.tgz#005b3fdf0ed96e88041330379e0da9a708eb2907"

     
···

       195
        
         integrity sha512-TJLx1ti1Cp7e53bCndV7DpMAcZL9+pqA4L9YD4kCrDQuYdA8boRnPh1l862w8AJHWTxEki/xtDu0FVPCq2HVrA==

     

       196
        
         dependencies:

     

       197
        
           jest "^23.5.0"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       198
        
       

     

       199
        
       "@types/estree@0.0.39":

     

       200
        
         version "0.0.39"

     
···

       286
        
         dependencies:

     

       287
        
           color-convert "^1.9.0"

     

       288
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       289
        
       anymatch@^2.0.0:

     

       290
        
         version "2.0.0"

     

       291
        
         resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-2.0.0.tgz#bcb24b4f37934d9aa7ac17b4adaf89e7c76ef2eb"

     
···

       362
        
         version "0.0.0"

     

       363
        
         resolved "https://registry.yarnpkg.com/array-reduce/-/array-reduce-0.0.0.tgz#173899d3ffd1c7d9383e4479525dbe278cab5f2b"

     

       364
        
         integrity sha1-FziZ0//Rx9k4PkR5Ul2+J4yrXys=

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       365
        
       

     

       366
        
       array-unique@^0.2.1:

     

       367
        
         version "0.2.1"

     
···

       964
        
           strip-ansi "^3.0.0"

     

       965
        
           supports-color "^2.0.0"

     

       966
        
       

     

       967
       -
       chalk@^2.0.0, chalk@^2.0.1, chalk@^2.4.0, chalk@^2.4.1, chalk@^2.4.2:

     

       968
        
         version "2.4.2"

     

       969
        
         resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"

     

       970
        
         integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==

     
···

       988
        
         resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-1.6.0.tgz#2ca20dbb9ceb32d4524a683303313f0304b1e497"

     

       989
        
         integrity sha512-vsGdkwSCDpWmP80ncATX7iea5DWQemg1UgCW5J8tqjU3lYw4FBYuj89J0CTVomA7BEfvSZd84GmHko+MxFQU2A==

     

       990
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       991
        
       clap@^1.0.9:

     

       992
        
         version "1.2.3"

     

       993
        
         resolved "https://registry.yarnpkg.com/clap/-/clap-1.2.3.tgz#4f36745b32008492557f46412d66d50cb99bce51"

     
···

       1004
        
           define-property "^0.2.5"

     

       1005
        
           isobject "^3.0.0"

     

       1006
        
           static-extend "^0.1.1"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1007
        
       

     

       1008
        
       cliui@^4.0.0:

     

       1009
        
         version "4.1.0"

     
···

       1128
        
         resolved "https://registry.yarnpkg.com/commander/-/commander-2.19.0.tgz#f6198aa84e5b83c46054b94ddedbfed5ee9ff12a"

     

       1129
        
         integrity sha512-6tvAOO+D6OENvRAh524Dh9jcfKTYDQAqvqezbCW82xj5X0pSrcpxtvRKHLG0yBY6SD7PSDrJaj+0AiOcKVd1Xg==

     

       1130
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1131
        
       commander@~2.17.1:

     

       1132
        
         version "2.17.1"

     

       1133
        
         resolved "https://registry.yarnpkg.com/commander/-/commander-2.17.1.tgz#bd77ab7de6de94205ceacc72f1716d29f20a77bf"

     
···

       1200
        
           js-yaml "^3.9.0"

     

       1201
        
           parse-json "^4.0.0"

     

       1202
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1203
        
       coveralls@^3.0.0:

     

       1204
        
         version "3.0.2"

     

       1205
        
         resolved "https://registry.yarnpkg.com/coveralls/-/coveralls-3.0.2.tgz#f5a0bcd90ca4e64e088b710fa8dda640aea4884f"

     
···

       1221
        
           shebang-command "^1.2.0"

     

       1222
        
           which "^1.2.9"

     

       1223
        
       

     

       1224
       -
       cross-spawn@^6.0.5:

     

       1225
        
         version "6.0.5"

     

       1226
        
         resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4"

     

       1227
        
         integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==

     
···

       1471
        
           whatwg-mimetype "^2.2.0"

     

       1472
        
           whatwg-url "^7.0.0"

     

       1473
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1474
        
       debug@=3.1.0:

     

       1475
        
         version "3.1.0"

     

       1476
        
         resolved "https://registry.yarnpkg.com/debug/-/debug-3.1.0.tgz#5bb5a0672628b64149566ba16819e61518c67261"

     
···

       1492
        
         dependencies:

     

       1493
        
           ms "^2.1.1"

     

       1494
        
       

     

       1495
       -
       debug@^4.1.0:

     

       1496
        
         version "4.1.1"

     

       1497
        
         resolved "https://registry.yarnpkg.com/debug/-/debug-4.1.1.tgz#3b72260255109c6b589cee050f1d516139664791"

     

       1498
        
         integrity sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==

     
···

       1516
        
         dependencies:

     

       1517
        
           mimic-response "^1.0.0"

     

       1518
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1519
        
       deep-extend@^0.6.0:

     

       1520
        
         version "0.6.0"

     

       1521
        
         resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.6.0.tgz#c4fa7c95404a17a9c3e8ca7e1537312b736330ac"

     
···

       1567
        
         resolved "https://registry.yarnpkg.com/defined/-/defined-1.0.0.tgz#c98d9bcef75674188e110969151199e39b1fa693"

     

       1568
        
         integrity sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=

     

       1569
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1570
        
       delayed-stream@~1.0.0:

     

       1571
        
         version "1.0.0"

     

       1572
        
         resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"

     
···

       1661
        
         version "1.3.102"

     

       1662
        
         resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.102.tgz#3ac43a037c8a63bca3dfa189eb3d90f097196787"

     

       1663
        
         integrity sha512-2nzZuXw/KBPnI3QX3UOCSRvJiVy7o9+VHRDQ3D/EHCvVc89X6aj/GlNmEgiR2GBIhmSWXIi4W1M5okA5ScSlNg==

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1664
        
       

     

       1665
        
       emojis-list@^2.0.0:

     

       1666
        
         version "2.1.0"

     
···

       1712
        
         resolved "https://registry.yarnpkg.com/es6-promisify/-/es6-promisify-6.0.1.tgz#6edaa45f3bd570ffe08febce66f7116be4b1cdb6"

     

       1713
        
         integrity sha512-J3ZkwbEnnO+fGAKrjVpeUAnZshAdfZvbhQpqfIH9kSAspReRC4nJnu8ewm55b4y9ElyeuhCTzJD0XiH8Tsbhlw==

     

       1714
        
       

     

       1715
       -
       escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.5:

     

       1716
        
         version "1.0.5"

     

       1717
        
         resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"

     

       1718
        
         integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=

     
···

       1784
        
           signal-exit "^3.0.0"

     

       1785
        
           strip-eof "^1.0.0"

     

       1786
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1787
        
       exit@^0.1.2:

     

       1788
        
         version "0.1.2"

     

       1789
        
         resolved "https://registry.yarnpkg.com/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c"

     
···

       1916
        
         dependencies:

     

       1917
        
           bser "^2.0.0"

     

       1918
        
       

     

       1919
       -
       figures@^1.0.1:

     

       1920
        
         version "1.7.0"

     

       1921
        
         resolved "https://registry.yarnpkg.com/figures/-/figures-1.7.0.tgz#cbe1e3affcf1cd44b80cadfed28dc793a9701d2e"

     

       1922
        
         integrity sha1-y+Hjr/zxzUS4DK3+0o3Hk6lwHS4=

     

       1923
        
         dependencies:

     

       1924
        
           escape-string-regexp "^1.0.5"

     

       1925
        
           object-assign "^4.1.0"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1926
        
       

     

       1927
        
       filename-regex@^2.0.0:

     

       1928
        
         version "2.0.1"

     
···

       1963
        
           repeat-string "^1.6.1"

     

       1964
        
           to-regex-range "^2.1.0"

     

       1965
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1966
        
       find-up@^1.0.0:

     

       1967
        
         version "1.1.2"

     

       1968
        
         resolved "https://registry.yarnpkg.com/find-up/-/find-up-1.1.2.tgz#6b2e9822b1a2ce0a60ab64d610eccad53cb24d0f"

     
···

       1978
        
         dependencies:

     

       1979
        
           locate-path "^2.0.0"

     

       1980
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1981
        
       flatten@^1.0.2:

     

       1982
        
         version "1.0.2"

     

       1983
        
         resolved "https://registry.yarnpkg.com/flatten/-/flatten-1.0.2.tgz#dae46a9d78fbe25292258cc1e780a41d95c03782"

     
···

       1990
        
         dependencies:

     

       1991
        
           babylon "^6.15.0"

     

       1992
        
           vlq "^0.2.1"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1993
        
       

     

       1994
        
       follow-redirects@1.0.0:

     

       1995
        
         version "1.0.0"

     
···

       2096
        
         resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"

     

       2097
        
         integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==

     

       2098
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2099
        
       gauge@~2.7.3:

     

       2100
        
         version "2.7.4"

     

       2101
        
         resolved "https://registry.yarnpkg.com/gauge/-/gauge-2.7.4.tgz#2c03405c7538c39d7eb37b317022e325fb018bf7"

     
···

       2122
        
         resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-1.0.3.tgz#f978fa4c90d1dfe7ff2d6beda2a515e713bdcf4a"

     

       2123
        
         integrity sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w==

     

       2124
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2125
        
       get-stream@^3.0.0:

     

       2126
        
         version "3.0.0"

     

       2127
        
         resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-3.0.0.tgz#8e943d1358dc37555054ecbe2edb05aa174ede14"

     

       2128
        
         integrity sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2129
        
       

     

       2130
        
       get-value@^2.0.3, get-value@^2.0.6:

     

       2131
        
         version "2.0.6"

     
···

       2192
        
         version "0.1.0"

     

       2193
        
         resolved "https://registry.yarnpkg.com/globalyzer/-/globalyzer-0.1.0.tgz#cb76da79555669a1519d5a8edf093afaa0bf1465"

     

       2194
        
         integrity sha512-40oNTM9UfG6aBmuKxk/giHn5nQ8RVz/SS4Ir6zgzOv9/qC3kKZ9v4etGTcJbEl/NyVQH7FGU7d+X1egr57Md2Q==

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2195
        
       

     

       2196
        
       globrex@^0.1.1:

     

       2197
        
         version "0.1.2"

     
···

       2379
        
           jsprim "^1.2.2"

     

       2380
        
           sshpk "^1.7.0"

     

       2381
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2382
        
       iconv-lite@0.4.24, iconv-lite@^0.4.4:

     

       2383
        
         version "0.4.24"

     

       2384
        
         resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"

     
···

       2452
        
         version "0.1.4"

     

       2453
        
         resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"

     

       2454
        
         integrity sha1-khi5srkoojixPcT7a21XbyMUU+o=

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2455
        
       

     

       2456
        
       indexes-of@^1.0.1:

     

       2457
        
         version "1.0.1"

     
···

       2546
        
         dependencies:

     

       2547
        
           ci-info "^1.5.0"

     

       2548
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2549
        
       is-color-stop@^1.0.0:

     

       2550
        
         version "1.1.0"

     

       2551
        
         resolved "https://registry.yarnpkg.com/is-color-stop/-/is-color-stop-1.1.0.tgz#cfff471aee4dd5c9e158598fbe12967b5cdad345"

     
···

       2629
        
         resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-1.0.0.tgz#ac468177c4943405a092fc8f29760c6ffc6206c0"

     

       2630
        
         integrity sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=

     

       2631
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2632
        
       is-finite@^1.0.0:

     

       2633
        
         version "1.0.2"

     

       2634
        
         resolved "https://registry.yarnpkg.com/is-finite/-/is-finite-1.0.2.tgz#cc6677695602be550ef11e8b4aa6305342b6d0aa"

     
···

       2660
        
         dependencies:

     

       2661
        
           is-extglob "^1.0.0"

     

       2662
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2663
        
       is-module@^1.0.0:

     

       2664
        
         version "1.0.0"

     

       2665
        
         resolved "https://registry.yarnpkg.com/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591"

     
···

       2684
        
         resolved "https://registry.yarnpkg.com/is-number/-/is-number-4.0.0.tgz#0026e37f5454d73e356dfe6564699867c6a7f0ff"

     

       2685
        
         integrity sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==

     

       2686
        
       

     

       2687
       -
       is-obj@^1.0.0:

     

       2688
        
         version "1.0.1"

     

       2689
        
         resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-1.0.1.tgz#3e4729ac1f5fde025cd7d83a896dab9f4f67db0f"

     

       2690
        
         integrity sha1-PkcprB9f3gJc19g6iW2rn09n2w8=

     

       2691
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2692
        
       is-plain-obj@^1.0.0:

     

       2693
        
         version "1.1.0"

     

       2694
        
         resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e"

     
···

       2711
        
         resolved "https://registry.yarnpkg.com/is-primitive/-/is-primitive-2.0.0.tgz#207bab91638499c07b2adf240a41a87210034575"

     

       2712
        
         integrity sha1-IHurkWOEmcB7Kt8kCkGochADRXU=

     

       2713
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2714
        
       is-regex@^1.0.4:

     

       2715
        
         version "1.0.4"

     

       2716
        
         resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.0.4.tgz#5517489b547091b0930e095654ced25ee97e9491"

     

       2717
        
         integrity sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=

     

       2718
        
         dependencies:

     

       2719
        
           has "^1.0.1"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2720
        
       

     

       2721
        
       is-resolvable@^1.0.0:

     

       2722
        
         version "1.1.0"

     
···

       3201
        
           argparse "^1.0.7"

     

       3202
        
           esprima "^4.0.0"

     

       3203
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3204
        
       js-yaml@~3.7.0:

     

       3205
        
         version "3.7.0"

     

       3206
        
         resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.7.0.tgz#5c967ddd837a9bfdca5f2de84253abe8a1c03b80"

     
···

       3374
        
           prelude-ls "~1.1.2"

     

       3375
        
           type-check "~0.3.2"

     

       3376
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3377
        
       load-json-file@^1.0.0:

     

       3378
        
         version "1.1.0"

     

       3379
        
         resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-1.1.0.tgz#956905708d58b4bab4c2261b04f59f31c99374c0"

     
···

       3413
        
           p-locate "^2.0.0"

     

       3414
        
           path-exists "^3.0.0"

     

       3415
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3416
        
       lodash.camelcase@^4.3.0:

     

       3417
        
         version "4.3.0"

     

       3418
        
         resolved "https://registry.yarnpkg.com/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz#b28aa6288a2b9fc651035c7711f65ab6190331a6"

     
···

       3443
        
         resolved "https://registry.yarnpkg.com/lodash.uniq/-/lodash.uniq-4.5.0.tgz#d0225373aeb652adc1bc82e4945339a842754773"

     

       3444
        
         integrity sha1-0CJTc662Uq3BvILklFM5qEJ1R3M=

     

       3445
        
       

     

       3446
       -
       lodash@^4.13.1, lodash@^4.17.10, lodash@^4.17.4:

     

       3447
        
         version "4.17.11"

     

       3448
        
         resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.11.tgz#b39ea6229ef607ecd89e2c8df12536891cac9b8d"

     

       3449
        
         integrity sha512-cQKh8igo5QUhZ7lg38DYWAxMvjSAKG0A8wGSVimP07SIUEK2UO+arSRKbRZWtelMtN5V0Hkwh5ryOto/SshYIg==

     
···

       3453
        
         resolved "https://registry.yarnpkg.com/log-driver/-/log-driver-1.2.7.tgz#63b95021f0702fedfa2c9bb0a24e7797d71871d8"

     

       3454
        
         integrity sha512-U7KCmLdqsGHBLeWqYlFA0V0Sl6P08EE1ZrmA9cxjUE0WVqT9qnyVDPz1kzpFEP0jdJuFnasWIfSd7fsaNXkpbg==

     

       3455
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3456
        
       loose-envify@^1.0.0:

     

       3457
        
         version "1.4.0"

     

       3458
        
         resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz#71ee51fa7be4caec1a63839f7e682d8132d30caf"

     
···

       3500
        
         integrity sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=

     

       3501
        
         dependencies:

     

       3502
        
           object-visit "^1.0.0"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3503
        
       

     

       3504
        
       math-expression-evaluator@^1.2.14:

     

       3505
        
         version "1.2.17"

     
···

       3607
        
           parse-glob "^3.0.4"

     

       3608
        
           regex-cache "^0.4.2"

     

       3609
        
       

     

       3610
       -
       micromatch@^3.1.4:

     

       3611
        
         version "3.1.10"

     

       3612
        
         resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-3.1.10.tgz#70859bc95c9840952f359a068a3fc49f9ecfac23"

     

       3613
        
         integrity sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==

     
···

       3899
        
           ignore-walk "^3.0.1"

     

       3900
        
           npm-bundled "^1.0.1"

     

       3901
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3902
        
       npm-run-all@^4.1.5:

     

       3903
        
         version "4.1.5"

     

       3904
        
         resolved "https://registry.yarnpkg.com/npm-run-all/-/npm-run-all-4.1.5.tgz#04476202a15ee0e2e214080861bff12a51d98fba"

     
···

       3921
        
         dependencies:

     

       3922
        
           path-key "^2.0.0"

     

       3923
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3924
        
       "npmlog@0 || 1 || 2 || 3 || 4", npmlog@^4.0.1, npmlog@^4.0.2, npmlog@^4.1.2:

     

       3925
        
         version "4.1.2"

     

       3926
        
         resolved "https://registry.yarnpkg.com/npmlog/-/npmlog-4.1.2.tgz#08a7f2a8bf734604779a9efa4ad5cc717abb954b"

     
···

       4024
        
         dependencies:

     

       4025
        
           wrappy "1"

     

       4026
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       4027
        
       optimist@^0.6.1:

     

       4028
        
         version "0.6.1"

     

       4029
        
         resolved "https://registry.yarnpkg.com/optimist/-/optimist-0.6.1.tgz#da3ea74686fa21a19a111c326e90eb15a0196686"

     
···

       4083
        
         dependencies:

     

       4084
        
           p-try "^1.0.0"

     

       4085
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       4086
        
       p-locate@^2.0.0:

     

       4087
        
         version "2.0.0"

     

       4088
        
         resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43"

     
···

       4090
        
         dependencies:

     

       4091
        
           p-limit "^1.1.0"

     

       4092
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       4093
        
       p-queue@^2.4.2:

     

       4094
        
         version "2.4.2"

     

       4095
        
         resolved "https://registry.yarnpkg.com/p-queue/-/p-queue-2.4.2.tgz#03609826682b743be9a22dba25051bd46724fc34"

     
···

       4100
        
         resolved "https://registry.yarnpkg.com/p-try/-/p-try-1.0.0.tgz#cbc79cdbaf8fd4228e13f621f2b1a237c1b207b3"

     

       4101
        
         integrity sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=

     

       4102
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       4103
        
       parse-glob@^3.0.4:

     

       4104
        
         version "3.0.4"

     

       4105
        
         resolved "https://registry.yarnpkg.com/parse-glob/-/parse-glob-3.0.4.tgz#b2c376cfb11f35513badd173ef0bb6e3a388391c"

     
···

       4151
        
         version "1.0.1"

     

       4152
        
         resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"

     

       4153
        
         integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18=

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       4154
        
       

     

       4155
        
       path-key@^2.0.0, path-key@^2.0.1:

     

       4156
        
         version "2.0.1"

     
···

       4216
        
         integrity sha1-9tXREJ4Z1j7fQo4L1X4Sd3YVM0s=

     

       4217
        
         dependencies:

     

       4218
        
           find-up "^2.1.0"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       4219
        
       

     

       4220
        
       pn@^1.1.0:

     

       4221
        
         version "1.1.0"

     
···

       4940
        
           kleur "^2.0.1"

     

       4941
        
           sisteransi "^0.1.1"

     

       4942
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       4943
        
       pseudomap@^1.0.2:

     

       4944
        
         version "1.0.2"

     

       4945
        
         resolved "https://registry.yarnpkg.com/pseudomap/-/pseudomap-1.0.2.tgz#f052a28da70e618917ef0a8ac34c1ae5a68286b3"

     
···

       4962
        
         version "2.0.1"

     

       4963
        
         resolved "https://registry.yarnpkg.com/pump/-/pump-2.0.1.tgz#12399add6e4cf7526d973cbc8b5ce2e2908b3909"

     

       4964
        
         integrity sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       4965
        
         dependencies:

     

       4966
        
           end-of-stream "^1.1.0"

     

       4967
        
           once "^1.3.1"

     
···

       5047
        
           normalize-package-data "^2.3.2"

     

       5048
        
           path-type "^3.0.0"

     

       5049
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5050
        
       readable-stream@^2.0.1, readable-stream@^2.0.6, readable-stream@^2.3.0, readable-stream@^2.3.5:

     

       5051
        
         version "2.3.6"

     

       5052
        
         resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.6.tgz#b11c27d88b8ff1fbe070643cf94b0c79ae1b0aaf"

     
···

       5285
        
         dependencies:

     

       5286
        
           path-parse "^1.0.6"

     

       5287
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5288
        
       ret@~0.1.10:

     

       5289
        
         version "0.1.15"

     

       5290
        
         resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc"

     
···

       5300
        
         resolved "https://registry.yarnpkg.com/rgba-regex/-/rgba-regex-1.0.0.tgz#43374e2e2ca0968b0ef1523460b7d730ff22eeb3"

     

       5301
        
         integrity sha1-QzdOLiyglosO8VI0YLfXMP8i7rM=

     

       5302
        
       

     

       5303
       -
       rimraf@2, rimraf@^2.5.4, rimraf@^2.6.1, rimraf@^2.6.3:

     

       5304
        
         version "2.6.3"

     

       5305
        
         resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.3.tgz#b2d104fe0d8fb27cf9e0a1cda8262dd3833c6cab"

     

       5306
        
         integrity sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==

     
···

       5459
        
         resolved "https://registry.yarnpkg.com/rsvp/-/rsvp-3.6.2.tgz#2e96491599a96cde1b515d5674a8f7a91452926a"

     

       5460
        
         integrity sha512-OfWGQTb9vnwRjwtA2QwpG2ICclHC3pgXZO5xt8H2EfgDquO0qVdSb5T88L4qJVAEugbS56pAuV4XZM58UX8ulw==

     

       5461
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5462
        
       sade@^1.4.0:

     

       5463
        
         version "1.4.2"

     

       5464
        
         resolved "https://registry.yarnpkg.com/sade/-/sade-1.4.2.tgz#b1946ef9ec62450b74e17d9fec30156c94f193a6"

     
···

       5503
        
         version "1.2.4"

     

       5504
        
         resolved "https://registry.yarnpkg.com/sax/-/sax-1.2.4.tgz#2816234e2378bddc4e5354fab5caa895df7100d9"

     

       5505
        
         integrity sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5506
        
       

     

       5507
        
       "semver@2 || 3 || 4 || 5", semver@^5.3.0, semver@^5.4.1, semver@^5.5.0:

     

       5508
        
         version "5.6.0"

     
···

       5590
        
           once "^1.3.1"

     

       5591
        
           simple-concat "^1.0.0"

     

       5592
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5593
        
       simple-swizzle@^0.2.2:

     

       5594
        
         version "0.2.2"

     

       5595
        
         resolved "https://registry.yarnpkg.com/simple-swizzle/-/simple-swizzle-0.2.2.tgz#a4da6b635ffcccca33f70d17cb92592de95e557a"

     
···

       5606
        
         version "1.0.0"

     

       5607
        
         resolved "https://registry.yarnpkg.com/slash/-/slash-1.0.0.tgz#c41f2f6c39fc16d1cd17ad4b5d896114ae470d55"

     

       5608
        
         integrity sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5609
        
       

     

       5610
        
       snapdragon-node@^2.0.1:

     

       5611
        
         version "2.1.1"

     
···

       5761
        
         resolved "https://registry.yarnpkg.com/stack-utils/-/stack-utils-1.0.2.tgz#33eba3897788558bebfc2db059dc158ec36cebb8"

     

       5762
        
         integrity sha512-MTX+MeG5U994cazkjd/9KNAapsHnibjMLnfXodlkXw76JEea0UiNzrqidzo1emMwk7w5Qhc9jd4Bn9TBb1MFwA==

     

       5763
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5764
        
       static-extend@^0.1.1:

     

       5765
        
         version "0.1.2"

     

       5766
        
         resolved "https://registry.yarnpkg.com/static-extend/-/static-extend-0.1.2.tgz#60809c39cbff55337226fd5e0b520f341f1fb5c6"

     
···

       5778
        
         version "1.1.0"

     

       5779
        
         resolved "https://registry.yarnpkg.com/strict-uri-encode/-/strict-uri-encode-1.1.0.tgz#279b225df1d582b1f54e65addd4352e18faa0713"

     

       5780
        
         integrity sha1-J5siXfHVgrH1TmWt3UNS4Y+qBxM=

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5781
        
       

     

       5782
        
       string-hash@^1.1.1:

     

       5783
        
         version "1.1.3"

     
···

       5824
        
         integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==

     

       5825
        
         dependencies:

     

       5826
        
           safe-buffer "~5.1.0"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5827
        
       

     

       5828
        
       strip-ansi@^3.0.0, strip-ansi@^3.0.1:

     

       5829
        
         version "3.0.1"

     
···

       5941
        
           unquote "~1.1.1"

     

       5942
        
           util.promisify "~1.0.0"

     

       5943
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5944
        
       symbol-tree@^3.2.2:

     

       5945
        
         version "3.2.2"

     

       5946
        
         resolved "https://registry.yarnpkg.com/symbol-tree/-/symbol-tree-3.2.2.tgz#ae27db38f660a7ae2e1c3b7d1bc290819b8519e6"

     

       5947
        
         integrity sha1-rifbOPZgp64uHDt9G8KQgZuFGeY=

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5948
        
       

     

       5949
        
       tar-fs@^1.13.0:

     

       5950
        
         version "1.16.3"

     
···

       6073
        
           extend-shallow "^3.0.2"

     

       6074
        
           regex-not "^1.0.2"

     

       6075
        
           safe-regex "^1.1.0"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       6076
        
       

     

       6077
        
       tough-cookie@>=2.3.3:

     

       6078
        
         version "3.0.0"

     
···

       6348
        
         resolved "https://registry.yarnpkg.com/which-pm-runs/-/which-pm-runs-1.0.0.tgz#670b3afbc552e0b55df6b7780ca74615f23ad1cb"

     

       6349
        
         integrity sha1-Zws6+8VS4LVd9rd4DKdGFfI60cs=

     

       6350
        
       

     

       6351
       -
       which@1, which@^1.2.12, which@^1.2.9, which@^1.3.0:

     

       6352
        
         version "1.3.1"

     

       6353
        
         resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"

     

       6354
        
         integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==

     
···

       6379
        
         dependencies:

     

       6380
        
           string-width "^1.0.1"

     

       6381
        
           strip-ansi "^3.0.1"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       6382
        
       

     

       6383
        
       wrappy@1:

     

       6384
        
         version "1.0.2"

     
···

       6450
        
           which-module "^2.0.0"

     

       6451
        
           y18n "^3.2.1"

     

       6452
        
           yargs-parser "^9.0.2"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       156
        
           core-js "^2.5.7"

     

       157
        
           regenerator-runtime "^0.12.0"

     

       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
       +
       

     

       166
        
       "@babel/template@^7.1.0", "@babel/template@^7.1.2", "@babel/template@^7.2.2":

     

       167
        
         version "7.2.2"

     

       168
        
         resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.2.2.tgz#005b3fdf0ed96e88041330379e0da9a708eb2907"

     
···

       202
        
         integrity sha512-TJLx1ti1Cp7e53bCndV7DpMAcZL9+pqA4L9YD4kCrDQuYdA8boRnPh1l862w8AJHWTxEki/xtDu0FVPCq2HVrA==

     

       203
        
         dependencies:

     

       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"

     

       212
        
       

     

       213
        
       "@types/estree@0.0.39":

     

       214
        
         version "0.0.39"

     
···

       300
        
         dependencies:

     

       301
        
           color-convert "^1.9.0"

     

       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
       +
       

     

       308
        
       anymatch@^2.0.0:

     

       309
        
         version "2.0.0"

     

       310
        
         resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-2.0.0.tgz#bcb24b4f37934d9aa7ac17b4adaf89e7c76ef2eb"

     
···

       381
        
         version "0.0.0"

     

       382
        
         resolved "https://registry.yarnpkg.com/array-reduce/-/array-reduce-0.0.0.tgz#173899d3ffd1c7d9383e4479525dbe278cab5f2b"

     

       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=

     

       396
        
       

     

       397
        
       array-unique@^0.2.1:

     

       398
        
         version "0.2.1"

     
···

       995
        
           strip-ansi "^3.0.0"

     

       996
        
           supports-color "^2.0.0"

     

       997
        
       

     

       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:

     

       999
        
         version "2.4.2"

     

       1000
        
         resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"

     

       1001
        
         integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==

     
···

       1019
        
         resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-1.6.0.tgz#2ca20dbb9ceb32d4524a683303313f0304b1e497"

     

       1020
        
         integrity sha512-vsGdkwSCDpWmP80ncATX7iea5DWQemg1UgCW5J8tqjU3lYw4FBYuj89J0CTVomA7BEfvSZd84GmHko+MxFQU2A==

     

       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
       +
       

     

       1027
        
       clap@^1.0.9:

     

       1028
        
         version "1.2.3"

     

       1029
        
         resolved "https://registry.yarnpkg.com/clap/-/clap-1.2.3.tgz#4f36745b32008492557f46412d66d50cb99bce51"

     
···

       1040
        
           define-property "^0.2.5"

     

       1041
        
           isobject "^3.0.0"

     

       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"

     

       1058
        
       

     

       1059
        
       cliui@^4.0.0:

     

       1060
        
         version "4.1.0"

     
···

       1179
        
         resolved "https://registry.yarnpkg.com/commander/-/commander-2.19.0.tgz#f6198aa84e5b83c46054b94ddedbfed5ee9ff12a"

     

       1180
        
         integrity sha512-6tvAOO+D6OENvRAh524Dh9jcfKTYDQAqvqezbCW82xj5X0pSrcpxtvRKHLG0yBY6SD7PSDrJaj+0AiOcKVd1Xg==

     

       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
       +
       

     

       1187
        
       commander@~2.17.1:

     

       1188
        
         version "2.17.1"

     

       1189
        
         resolved "https://registry.yarnpkg.com/commander/-/commander-2.17.1.tgz#bd77ab7de6de94205ceacc72f1716d29f20a77bf"

     
···

       1256
        
           js-yaml "^3.9.0"

     

       1257
        
           parse-json "^4.0.0"

     

       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
       +
       

     

       1269
        
       coveralls@^3.0.0:

     

       1270
        
         version "3.0.2"

     

       1271
        
         resolved "https://registry.yarnpkg.com/coveralls/-/coveralls-3.0.2.tgz#f5a0bcd90ca4e64e088b710fa8dda640aea4884f"

     
···

       1287
        
           shebang-command "^1.2.0"

     

       1288
        
           which "^1.2.9"

     

       1289
        
       

     

       1290
       +
       cross-spawn@^6.0.0, cross-spawn@^6.0.5:

     

       1291
        
         version "6.0.5"

     

       1292
        
         resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4"

     

       1293
        
         integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==

     
···

       1537
        
           whatwg-mimetype "^2.2.0"

     

       1538
        
           whatwg-url "^7.0.0"

     

       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
       +
       

     

       1545
        
       debug@=3.1.0:

     

       1546
        
         version "3.1.0"

     

       1547
        
         resolved "https://registry.yarnpkg.com/debug/-/debug-3.1.0.tgz#5bb5a0672628b64149566ba16819e61518c67261"

     
···

       1563
        
         dependencies:

     

       1564
        
           ms "^2.1.1"

     

       1565
        
       

     

       1566
       +
       debug@^4.0.1, debug@^4.1.0:

     

       1567
        
         version "4.1.1"

     

       1568
        
         resolved "https://registry.yarnpkg.com/debug/-/debug-4.1.1.tgz#3b72260255109c6b589cee050f1d516139664791"

     

       1569
        
         integrity sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==

     
···

       1587
        
         dependencies:

     

       1588
        
           mimic-response "^1.0.0"

     

       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
       +
       

     

       1595
        
       deep-extend@^0.6.0:

     

       1596
        
         version "0.6.0"

     

       1597
        
         resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.6.0.tgz#c4fa7c95404a17a9c3e8ca7e1537312b736330ac"

     
···

       1643
        
         resolved "https://registry.yarnpkg.com/defined/-/defined-1.0.0.tgz#c98d9bcef75674188e110969151199e39b1fa693"

     

       1644
        
         integrity sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=

     

       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
       +
       

     

       1658
        
       delayed-stream@~1.0.0:

     

       1659
        
         version "1.0.0"

     

       1660
        
         resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"

     
···

       1749
        
         version "1.3.102"

     

       1750
        
         resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.102.tgz#3ac43a037c8a63bca3dfa189eb3d90f097196787"

     

       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=

     

       1757
        
       

     

       1758
        
       emojis-list@^2.0.0:

     

       1759
        
         version "2.1.0"

     
···

       1805
        
         resolved "https://registry.yarnpkg.com/es6-promisify/-/es6-promisify-6.0.1.tgz#6edaa45f3bd570ffe08febce66f7116be4b1cdb6"

     

       1806
        
         integrity sha512-J3ZkwbEnnO+fGAKrjVpeUAnZshAdfZvbhQpqfIH9kSAspReRC4nJnu8ewm55b4y9ElyeuhCTzJD0XiH8Tsbhlw==

     

       1807
        
       

     

       1808
       +
       escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.4, escape-string-regexp@^1.0.5:

     

       1809
        
         version "1.0.5"

     

       1810
        
         resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"

     

       1811
        
         integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=

     
···

       1877
        
           signal-exit "^3.0.0"

     

       1878
        
           strip-eof "^1.0.0"

     

       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
       +
       

     

       1893
        
       exit@^0.1.2:

     

       1894
        
         version "0.1.2"

     

       1895
        
         resolved "https://registry.yarnpkg.com/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c"

     
···

       2022
        
         dependencies:

     

       2023
        
           bser "^2.0.0"

     

       2024
        
       

     

       2025
       +
       figures@^1.0.1, figures@^1.7.0:

     

       2026
        
         version "1.7.0"

     

       2027
        
         resolved "https://registry.yarnpkg.com/figures/-/figures-1.7.0.tgz#cbe1e3affcf1cd44b80cadfed28dc793a9701d2e"

     

       2028
        
         integrity sha1-y+Hjr/zxzUS4DK3+0o3Hk6lwHS4=

     

       2029
        
         dependencies:

     

       2030
        
           escape-string-regexp "^1.0.5"

     

       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"

     

       2039
        
       

     

       2040
        
       filename-regex@^2.0.0:

     

       2041
        
         version "2.0.1"

     
···

       2076
        
           repeat-string "^1.6.1"

     

       2077
        
           to-regex-range "^2.1.0"

     

       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
       +
       

     

       2084
        
       find-up@^1.0.0:

     

       2085
        
         version "1.1.2"

     

       2086
        
         resolved "https://registry.yarnpkg.com/find-up/-/find-up-1.1.2.tgz#6b2e9822b1a2ce0a60ab64d610eccad53cb24d0f"

     
···

       2096
        
         dependencies:

     

       2097
        
           locate-path "^2.0.0"

     

       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
       +
       

     

       2106
        
       flatten@^1.0.2:

     

       2107
        
         version "1.0.2"

     

       2108
        
         resolved "https://registry.yarnpkg.com/flatten/-/flatten-1.0.2.tgz#dae46a9d78fbe25292258cc1e780a41d95c03782"

     
···

       2115
        
         dependencies:

     

       2116
        
           babylon "^6.15.0"

     

       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=

     

       2123
        
       

     

       2124
        
       follow-redirects@1.0.0:

     

       2125
        
         version "1.0.0"

     
···

       2226
        
         resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"

     

       2227
        
         integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==

     

       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
       +
       

     

       2238
        
       gauge@~2.7.3:

     

       2239
        
         version "2.7.4"

     

       2240
        
         resolved "https://registry.yarnpkg.com/gauge/-/gauge-2.7.4.tgz#2c03405c7538c39d7eb37b317022e325fb018bf7"

     
···

       2261
        
         resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-1.0.3.tgz#f978fa4c90d1dfe7ff2d6beda2a515e713bdcf4a"

     

       2262
        
         integrity sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w==

     

       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
       +
       

     

       2274
        
       get-stream@^3.0.0:

     

       2275
        
         version "3.0.0"

     

       2276
        
         resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-3.0.0.tgz#8e943d1358dc37555054ecbe2edb05aa174ede14"

     

       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"

     

       2285
        
       

     

       2286
        
       get-value@^2.0.3, get-value@^2.0.6:

     

       2287
        
         version "2.0.6"

     
···

       2348
        
         version "0.1.0"

     

       2349
        
         resolved "https://registry.yarnpkg.com/globalyzer/-/globalyzer-0.1.0.tgz#cb76da79555669a1519d5a8edf093afaa0bf1465"

     

       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"

     

       2362
        
       

     

       2363
        
       globrex@^0.1.1:

     

       2364
        
         version "0.1.2"

     
···

       2546
        
           jsprim "^1.2.2"

     

       2547
        
           sshpk "^1.7.0"

     

       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
       +
       

     

       2565
        
       iconv-lite@0.4.24, iconv-lite@^0.4.4:

     

       2566
        
         version "0.4.24"

     

       2567
        
         resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"

     
···

       2635
        
         version "0.1.4"

     

       2636
        
         resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"

     

       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=

     

       2643
        
       

     

       2644
        
       indexes-of@^1.0.1:

     

       2645
        
         version "1.0.1"

     
···

       2734
        
         dependencies:

     

       2735
        
           ci-info "^1.5.0"

     

       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
       +
       

     

       2744
        
       is-color-stop@^1.0.0:

     

       2745
        
         version "1.1.0"

     

       2746
        
         resolved "https://registry.yarnpkg.com/is-color-stop/-/is-color-stop-1.1.0.tgz#cfff471aee4dd5c9e158598fbe12967b5cdad345"

     
···

       2824
        
         resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-1.0.0.tgz#ac468177c4943405a092fc8f29760c6ffc6206c0"

     

       2825
        
         integrity sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=

     

       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
       +
       

     

       2832
        
       is-finite@^1.0.0:

     

       2833
        
         version "1.0.2"

     

       2834
        
         resolved "https://registry.yarnpkg.com/is-finite/-/is-finite-1.0.2.tgz#cc6677695602be550ef11e8b4aa6305342b6d0aa"

     
···

       2860
        
         dependencies:

     

       2861
        
           is-extglob "^1.0.0"

     

       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
       +
       

     

       2870
        
       is-module@^1.0.0:

     

       2871
        
         version "1.0.0"

     

       2872
        
         resolved "https://registry.yarnpkg.com/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591"

     
···

       2891
        
         resolved "https://registry.yarnpkg.com/is-number/-/is-number-4.0.0.tgz#0026e37f5454d73e356dfe6564699867c6a7f0ff"

     

       2892
        
         integrity sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==

     

       2893
        
       

     

       2894
       +
       is-obj@^1.0.0, is-obj@^1.0.1:

     

       2895
        
         version "1.0.1"

     

       2896
        
         resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-1.0.1.tgz#3e4729ac1f5fde025cd7d83a896dab9f4f67db0f"

     

       2897
        
         integrity sha1-PkcprB9f3gJc19g6iW2rn09n2w8=

     

       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
       +
       

     

       2925
        
       is-plain-obj@^1.0.0:

     

       2926
        
         version "1.1.0"

     

       2927
        
         resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e"

     
···

       2944
        
         resolved "https://registry.yarnpkg.com/is-primitive/-/is-primitive-2.0.0.tgz#207bab91638499c07b2adf240a41a87210034575"

     

       2945
        
         integrity sha1-IHurkWOEmcB7Kt8kCkGochADRXU=

     

       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
       +
       

     

       2952
        
       is-regex@^1.0.4:

     

       2953
        
         version "1.0.4"

     

       2954
        
         resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.0.4.tgz#5517489b547091b0930e095654ced25ee97e9491"

     

       2955
        
         integrity sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=

     

       2956
        
         dependencies:

     

       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=

     

       2963
        
       

     

       2964
        
       is-resolvable@^1.0.0:

     

       2965
        
         version "1.1.0"

     
···

       3444
        
           argparse "^1.0.7"

     

       3445
        
           esprima "^4.0.0"

     

       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
       +
       

     

       3455
        
       js-yaml@~3.7.0:

     

       3456
        
         version "3.7.0"

     

       3457
        
         resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.7.0.tgz#5c967ddd837a9bfdca5f2de84253abe8a1c03b80"

     
···

       3625
        
           prelude-ls "~1.1.2"

     

       3626
        
           type-check "~0.3.2"

     

       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
       +
       

     

       3703
        
       load-json-file@^1.0.0:

     

       3704
        
         version "1.1.0"

     

       3705
        
         resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-1.1.0.tgz#956905708d58b4bab4c2261b04f59f31c99374c0"

     
···

       3739
        
           p-locate "^2.0.0"

     

       3740
        
           path-exists "^3.0.0"

     

       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
       +
       

     

       3750
        
       lodash.camelcase@^4.3.0:

     

       3751
        
         version "4.3.0"

     

       3752
        
         resolved "https://registry.yarnpkg.com/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz#b28aa6288a2b9fc651035c7711f65ab6190331a6"

     
···

       3777
        
         resolved "https://registry.yarnpkg.com/lodash.uniq/-/lodash.uniq-4.5.0.tgz#d0225373aeb652adc1bc82e4945339a842754773"

     

       3778
        
         integrity sha1-0CJTc662Uq3BvILklFM5qEJ1R3M=

     

       3779
        
       

     

       3780
       +
       lodash@^4.13.1, lodash@^4.17.10, lodash@^4.17.11, lodash@^4.17.4:

     

       3781
        
         version "4.17.11"

     

       3782
        
         resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.11.tgz#b39ea6229ef607ecd89e2c8df12536891cac9b8d"

     

       3783
        
         integrity sha512-cQKh8igo5QUhZ7lg38DYWAxMvjSAKG0A8wGSVimP07SIUEK2UO+arSRKbRZWtelMtN5V0Hkwh5ryOto/SshYIg==

     
···

       3787
        
         resolved "https://registry.yarnpkg.com/log-driver/-/log-driver-1.2.7.tgz#63b95021f0702fedfa2c9bb0a24e7797d71871d8"

     

       3788
        
         integrity sha512-U7KCmLdqsGHBLeWqYlFA0V0Sl6P08EE1ZrmA9cxjUE0WVqT9qnyVDPz1kzpFEP0jdJuFnasWIfSd7fsaNXkpbg==

     

       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
       +
       

     

       3813
        
       loose-envify@^1.0.0:

     

       3814
        
         version "1.4.0"

     

       3815
        
         resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz#71ee51fa7be4caec1a63839f7e682d8132d30caf"

     
···

       3857
        
         integrity sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=

     

       3858
        
         dependencies:

     

       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"

     

       3867
        
       

     

       3868
        
       math-expression-evaluator@^1.2.14:

     

       3869
        
         version "1.2.17"

     
···

       3971
        
           parse-glob "^3.0.4"

     

       3972
        
           regex-cache "^0.4.2"

     

       3973
        
       

     

       3974
       +
       micromatch@^3.1.4, micromatch@^3.1.8:

     

       3975
        
         version "3.1.10"

     

       3976
        
         resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-3.1.10.tgz#70859bc95c9840952f359a068a3fc49f9ecfac23"

     

       3977
        
         integrity sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==

     
···

       4263
        
           ignore-walk "^3.0.1"

     

       4264
        
           npm-bundled "^1.0.1"

     

       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
       +
       

     

       4273
        
       npm-run-all@^4.1.5:

     

       4274
        
         version "4.1.5"

     

       4275
        
         resolved "https://registry.yarnpkg.com/npm-run-all/-/npm-run-all-4.1.5.tgz#04476202a15ee0e2e214080861bff12a51d98fba"

     
···

       4292
        
         dependencies:

     

       4293
        
           path-key "^2.0.0"

     

       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
       +
       

     

       4304
        
       "npmlog@0 || 1 || 2 || 3 || 4", npmlog@^4.0.1, npmlog@^4.0.2, npmlog@^4.1.2:

     

       4305
        
         version "4.1.2"

     

       4306
        
         resolved "https://registry.yarnpkg.com/npmlog/-/npmlog-4.1.2.tgz#08a7f2a8bf734604779a9efa4ad5cc717abb954b"

     
···

       4404
        
         dependencies:

     

       4405
        
           wrappy "1"

     

       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
       +
       

     

       4414
        
       optimist@^0.6.1:

     

       4415
        
         version "0.6.1"

     

       4416
        
         resolved "https://registry.yarnpkg.com/optimist/-/optimist-0.6.1.tgz#da3ea74686fa21a19a111c326e90eb15a0196686"

     
···

       4470
        
         dependencies:

     

       4471
        
           p-try "^1.0.0"

     

       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
       +
       

     

       4480
        
       p-locate@^2.0.0:

     

       4481
        
         version "2.0.0"

     

       4482
        
         resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43"

     
···

       4484
        
         dependencies:

     

       4485
        
           p-limit "^1.1.0"

     

       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
       +
       

     

       4504
        
       p-queue@^2.4.2:

     

       4505
        
         version "2.4.2"

     

       4506
        
         resolved "https://registry.yarnpkg.com/p-queue/-/p-queue-2.4.2.tgz#03609826682b743be9a22dba25051bd46724fc34"

     
···

       4511
        
         resolved "https://registry.yarnpkg.com/p-try/-/p-try-1.0.0.tgz#cbc79cdbaf8fd4228e13f621f2b1a237c1b207b3"

     

       4512
        
         integrity sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=

     

       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
       +
       

     

       4519
        
       parse-glob@^3.0.4:

     

       4520
        
         version "3.0.4"

     

       4521
        
         resolved "https://registry.yarnpkg.com/parse-glob/-/parse-glob-3.0.4.tgz#b2c376cfb11f35513badd173ef0bb6e3a388391c"

     
···

       4567
        
         version "1.0.1"

     

       4568
        
         resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"

     

       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=

     

       4575
        
       

     

       4576
        
       path-key@^2.0.0, path-key@^2.0.1:

     

       4577
        
         version "2.0.1"

     
···

       4637
        
         integrity sha1-9tXREJ4Z1j7fQo4L1X4Sd3YVM0s=

     

       4638
        
         dependencies:

     

       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"

     

       4654
        
       

     

       4655
        
       pn@^1.1.0:

     

       4656
        
         version "1.1.0"

     
···

       5375
        
           kleur "^2.0.1"

     

       5376
        
           sisteransi "^0.1.1"

     

       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
       +
       

     

       5383
        
       pseudomap@^1.0.2:

     

       5384
        
         version "1.0.2"

     

       5385
        
         resolved "https://registry.yarnpkg.com/pseudomap/-/pseudomap-1.0.2.tgz#f052a28da70e618917ef0a8ac34c1ae5a68286b3"

     
···

       5402
        
         version "2.0.1"

     

       5403
        
         resolved "https://registry.yarnpkg.com/pump/-/pump-2.0.1.tgz#12399add6e4cf7526d973cbc8b5ce2e2908b3909"

     

       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==

     

       5413
        
         dependencies:

     

       5414
        
           end-of-stream "^1.1.0"

     

       5415
        
           once "^1.3.1"

     
···

       5495
        
           normalize-package-data "^2.3.2"

     

       5496
        
           path-type "^3.0.0"

     

       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
       +
       

     

       5507
        
       readable-stream@^2.0.1, readable-stream@^2.0.6, readable-stream@^2.3.0, readable-stream@^2.3.5:

     

       5508
        
         version "2.3.6"

     

       5509
        
         resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.6.tgz#b11c27d88b8ff1fbe070643cf94b0c79ae1b0aaf"

     
···

       5742
        
         dependencies:

     

       5743
        
           path-parse "^1.0.6"

     

       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
       +
       

     

       5753
        
       ret@~0.1.10:

     

       5754
        
         version "0.1.15"

     

       5755
        
         resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc"

     
···

       5765
        
         resolved "https://registry.yarnpkg.com/rgba-regex/-/rgba-regex-1.0.0.tgz#43374e2e2ca0968b0ef1523460b7d730ff22eeb3"

     

       5766
        
         integrity sha1-QzdOLiyglosO8VI0YLfXMP8i7rM=

     

       5767
        
       

     

       5768
       +
       rimraf@2, rimraf@^2.2.8, rimraf@^2.5.4, rimraf@^2.6.1, rimraf@^2.6.3:

     

       5769
        
         version "2.6.3"

     

       5770
        
         resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.3.tgz#b2d104fe0d8fb27cf9e0a1cda8262dd3833c6cab"

     

       5771
        
         integrity sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==

     
···

       5924
        
         resolved "https://registry.yarnpkg.com/rsvp/-/rsvp-3.6.2.tgz#2e96491599a96cde1b515d5674a8f7a91452926a"

     

       5925
        
         integrity sha512-OfWGQTb9vnwRjwtA2QwpG2ICclHC3pgXZO5xt8H2EfgDquO0qVdSb5T88L4qJVAEugbS56pAuV4XZM58UX8ulw==

     

       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
       +
       

     

       5939
        
       sade@^1.4.0:

     

       5940
        
         version "1.4.2"

     

       5941
        
         resolved "https://registry.yarnpkg.com/sade/-/sade-1.4.2.tgz#b1946ef9ec62450b74e17d9fec30156c94f193a6"

     
···

       5980
        
         version "1.2.4"

     

       5981
        
         resolved "https://registry.yarnpkg.com/sax/-/sax-1.2.4.tgz#2816234e2378bddc4e5354fab5caa895df7100d9"

     

       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=

     

       5988
        
       

     

       5989
        
       "semver@2 || 3 || 4 || 5", semver@^5.3.0, semver@^5.4.1, semver@^5.5.0:

     

       5990
        
         version "5.6.0"

     
···

       6072
        
           once "^1.3.1"

     

       6073
        
           simple-concat "^1.0.0"

     

       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
       +
       

     

       6082
        
       simple-swizzle@^0.2.2:

     

       6083
        
         version "0.2.2"

     

       6084
        
         resolved "https://registry.yarnpkg.com/simple-swizzle/-/simple-swizzle-0.2.2.tgz#a4da6b635ffcccca33f70d17cb92592de95e557a"

     
···

       6095
        
         version "1.0.0"

     

       6096
        
         resolved "https://registry.yarnpkg.com/slash/-/slash-1.0.0.tgz#c41f2f6c39fc16d1cd17ad4b5d896114ae470d55"

     

       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=

     

       6108
        
       

     

       6109
        
       snapdragon-node@^2.0.1:

     

       6110
        
         version "2.1.1"

     
···

       6260
        
         resolved "https://registry.yarnpkg.com/stack-utils/-/stack-utils-1.0.2.tgz#33eba3897788558bebfc2db059dc158ec36cebb8"

     

       6261
        
         integrity sha512-MTX+MeG5U994cazkjd/9KNAapsHnibjMLnfXodlkXw76JEea0UiNzrqidzo1emMwk7w5Qhc9jd4Bn9TBb1MFwA==

     

       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
       +
       

     

       6268
        
       static-extend@^0.1.1:

     

       6269
        
         version "0.1.2"

     

       6270
        
         resolved "https://registry.yarnpkg.com/static-extend/-/static-extend-0.1.2.tgz#60809c39cbff55337226fd5e0b520f341f1fb5c6"

     
···

       6282
        
         version "1.1.0"

     

       6283
        
         resolved "https://registry.yarnpkg.com/strict-uri-encode/-/strict-uri-encode-1.1.0.tgz#279b225df1d582b1f54e65addd4352e18faa0713"

     

       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=

     

       6290
        
       

     

       6291
        
       string-hash@^1.1.1:

     

       6292
        
         version "1.1.3"

     
···

       6333
        
         integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==

     

       6334
        
         dependencies:

     

       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"

     

       6345
        
       

     

       6346
        
       strip-ansi@^3.0.0, strip-ansi@^3.0.1:

     

       6347
        
         version "3.0.1"

     
···

       6459
        
           unquote "~1.1.1"

     

       6460
        
           util.promisify "~1.0.0"

     

       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
       +
       

     

       6467
        
       symbol-tree@^3.2.2:

     

       6468
        
         version "3.2.2"

     

       6469
        
         resolved "https://registry.yarnpkg.com/symbol-tree/-/symbol-tree-3.2.2.tgz#ae27db38f660a7ae2e1c3b7d1bc290819b8519e6"

     

       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==

     

       6476
        
       

     

       6477
        
       tar-fs@^1.13.0:

     

       6478
        
         version "1.16.3"

     
···

       6601
        
           extend-shallow "^3.0.2"

     

       6602
        
           regex-not "^1.0.2"

     

       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=

     

       6609
        
       

     

       6610
        
       tough-cookie@>=2.3.3:

     

       6611
        
         version "3.0.0"

     
···

       6881
        
         resolved "https://registry.yarnpkg.com/which-pm-runs/-/which-pm-runs-1.0.0.tgz#670b3afbc552e0b55df6b7780ca74615f23ad1cb"

     

       6882
        
         integrity sha1-Zws6+8VS4LVd9rd4DKdGFfI60cs=

     

       6883
        
       

     

       6884
       +
       which@1, which@^1.2.10, which@^1.2.12, which@^1.2.9, which@^1.3.0:

     

       6885
        
         version "1.3.1"

     

       6886
        
         resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"

     

       6887
        
         integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==

     
···

       6912
        
         dependencies:

     

       6913
        
           string-width "^1.0.1"

     

       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"

     

       6923
        
       

     

       6924
        
       wrappy@1:

     

       6925
        
         version "1.0.2"

     
···

       6991
        
           which-module "^2.0.0"

     

       6992
        
           y18n "^3.2.1"

     

       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"