commit e82aa6aaca78041a512e32750dfe7767a2ab5ce9 · kitten.sh/wonka

.changeset/beige-worms-help.md

···

       1
       1
       +
       ---

     

       2
       2
       +
       'wonka': minor

     

       3
       3
       +
       ---

     

       4
       4
       +
       

     

       5
       5
       +
       Implement `toAsyncIterable`, converting a Wonka source to a JS Async Iterable.

+160

src/__tests__/sinks.test.ts

···

       229
       229
        
         });

     

       230
       230
        
       });

     

       231
       231
        
       

     

       232
       232
       +
       describe('toAsyncIterable', () => {

     

       233
       233
       +
         it('creates an async iterable mirroring the Wonka source', async () => {

     

       234
       234
       +
           let pulls = 0;

     

       235
       235
       +
           let sink: Sink<any> | null = null;

     

       236
       236
       +
       

     

       237
       237
       +
           const source: Source<any> = _sink => {

     

       238
       238
       +
             sink = _sink;

     

       239
       239
       +
             sink(

     

       240
       240
       +
               start(signal => {

     

       241
       241
       +
                 if (signal === TalkbackKind.Pull) pulls++;

     

       242
       242
       +
               })

     

       243
       243
       +
             );

     

       244
       244
       +
           };

     

       245
       245
       +
       

     

       246
       246
       +
           const asyncIterator = sinks.toAsyncIterable(source)[Symbol.asyncIterator]();

     

       247
       247
       +
       

     

       248
       248
       +
           expect(pulls).toBe(1);

     

       249
       249
       +
           sink!(push(0));

     

       250
       250
       +
           expect(await asyncIterator.next()).toEqual({ value: 0, done: false });

     

       251
       251
       +
           expect(pulls).toBe(2);

     

       252
       252
       +
       

     

       253
       253
       +
           sink!(push(1));

     

       254
       254
       +
           expect(await asyncIterator.next()).toEqual({ value: 1, done: false });

     

       255
       255
       +
           expect(pulls).toBe(3);

     

       256
       256
       +
       

     

       257
       257
       +
           sink!(SignalKind.End);

     

       258
       258
       +
           expect(await asyncIterator.next()).toEqual({ done: true });

     

       259
       259
       +
           expect(pulls).toBe(3);

     

       260
       260
       +
         });

     

       261
       261
       +
       

     

       262
       262
       +
         it('buffers actively pushed values', async () => {

     

       263
       263
       +
           let pulls = 0;

     

       264
       264
       +
           let sink: Sink<any> | null = null;

     

       265
       265
       +
       

     

       266
       266
       +
           const source: Source<any> = _sink => {

     

       267
       267
       +
             sink = _sink;

     

       268
       268
       +
             sink(

     

       269
       269
       +
               start(signal => {

     

       270
       270
       +
                 if (signal === TalkbackKind.Pull) pulls++;

     

       271
       271
       +
               })

     

       272
       272
       +
             );

     

       273
       273
       +
           };

     

       274
       274
       +
       

     

       275
       275
       +
           const asyncIterator = sinks.toAsyncIterable(source)[Symbol.asyncIterator]();

     

       276
       276
       +
       

     

       277
       277
       +
           sink!(push(0));

     

       278
       278
       +
           sink!(push(1));

     

       279
       279
       +
           sink!(SignalKind.End);

     

       280
       280
       +
       

     

       281
       281
       +
           expect(pulls).toBe(1);

     

       282
       282
       +
           expect(await asyncIterator.next()).toEqual({ value: 0, done: false });

     

       283
       283
       +
           expect(await asyncIterator.next()).toEqual({ value: 1, done: false });

     

       284
       284
       +
           expect(await asyncIterator.next()).toEqual({ done: true });

     

       285
       285
       +
         });

     

       286
       286
       +
       

     

       287
       287
       +
         it('asynchronously waits for pulled values', async () => {

     

       288
       288
       +
           let pulls = 0;

     

       289
       289
       +
           let sink: Sink<any> | null = null;

     

       290
       290
       +
       

     

       291
       291
       +
           const source: Source<any> = _sink => {

     

       292
       292
       +
             sink = _sink;

     

       293
       293
       +
             sink(

     

       294
       294
       +
               start(signal => {

     

       295
       295
       +
                 if (signal === TalkbackKind.Pull) pulls++;

     

       296
       296
       +
               })

     

       297
       297
       +
             );

     

       298
       298
       +
           };

     

       299
       299
       +
       

     

       300
       300
       +
           const asyncIterator = sinks.toAsyncIterable(source)[Symbol.asyncIterator]();

     

       301
       301
       +
           expect(pulls).toBe(1);

     

       302
       302
       +
       

     

       303
       303
       +
           let resolved = false;

     

       304
       304
       +
       

     

       305
       305
       +
           const promise = asyncIterator.next().then(value => {

     

       306
       306
       +
             resolved = true;

     

       307
       307
       +
             return value;

     

       308
       308
       +
           });

     

       309
       309
       +
       

     

       310
       310
       +
           await Promise.resolve();

     

       311
       311
       +
           expect(resolved).toBe(false);

     

       312
       312
       +
       

     

       313
       313
       +
           sink!(push(0));

     

       314
       314
       +
           sink!(SignalKind.End);

     

       315
       315
       +
           expect(await promise).toEqual({ value: 0, done: false });

     

       316
       316
       +
           expect(await asyncIterator.next()).toEqual({ done: true });

     

       317
       317
       +
         });

     

       318
       318
       +
       

     

       319
       319
       +
         it('supports cancellation via return', async () => {

     

       320
       320
       +
           let ended = false;

     

       321
       321
       +
           let sink: Sink<any> | null = null;

     

       322
       322
       +
       

     

       323
       323
       +
           const source: Source<any> = _sink => {

     

       324
       324
       +
             sink = _sink;

     

       325
       325
       +
             sink(

     

       326
       326
       +
               start(signal => {

     

       327
       327
       +
                 if (signal === TalkbackKind.Close) ended = true;

     

       328
       328
       +
               })

     

       329
       329
       +
             );

     

       330
       330
       +
           };

     

       331
       331
       +
       

     

       332
       332
       +
           const asyncIterator = sinks.toAsyncIterable(source)[Symbol.asyncIterator]();

     

       333
       333
       +
       

     

       334
       334
       +
           sink!(push(0));

     

       335
       335
       +
           expect(await asyncIterator.next()).toEqual({ value: 0, done: false });

     

       336
       336
       +
           expect(await asyncIterator.return!()).toEqual({ done: true });

     

       337
       337
       +
       

     

       338
       338
       +
           sink!(push(1));

     

       339
       339
       +
           expect(await asyncIterator.next()).toEqual({ done: true });

     

       340
       340
       +
       

     

       341
       341
       +
           expect(ended).toBeTruthy();

     

       342
       342
       +
         });

     

       343
       343
       +
       

     

       344
       344
       +
         it('supports for-await-of', async () => {

     

       345
       345
       +
           let pulls = 0;

     

       346
       346
       +
       

     

       347
       347
       +
           const source: Source<any> = sink => {

     

       348
       348
       +
             sink(

     

       349
       349
       +
               start(signal => {

     

       350
       350
       +
                 if (signal === TalkbackKind.Pull) {

     

       351
       351
       +
                   sink(pulls < 3 ? push(pulls++) : SignalKind.End);

     

       352
       352
       +
                 }

     

       353
       353
       +
               })

     

       354
       354
       +
             );

     

       355
       355
       +
           };

     

       356
       356
       +
       

     

       357
       357
       +
           const iterable = sinks.toAsyncIterable(source);

     

       358
       358
       +
           const values: any[] = [];

     

       359
       359
       +
           for await (const value of iterable) {

     

       360
       360
       +
             values.push(value);

     

       361
       361
       +
           }

     

       362
       362
       +
       

     

       363
       363
       +
           expect(values).toEqual([0, 1, 2]);

     

       364
       364
       +
         });

     

       365
       365
       +
       

     

       366
       366
       +
         it('supports for-await-of with early break', async () => {

     

       367
       367
       +
           let pulls = 0;

     

       368
       368
       +
           let closed = false;

     

       369
       369
       +
       

     

       370
       370
       +
           const source: Source<any> = sink => {

     

       371
       371
       +
             sink(

     

       372
       372
       +
               start(signal => {

     

       373
       373
       +
                 if (signal === TalkbackKind.Pull) {

     

       374
       374
       +
                   sink(pulls < 3 ? push(pulls++) : SignalKind.End);

     

       375
       375
       +
                 } else {

     

       376
       376
       +
                   closed = true;

     

       377
       377
       +
                 }

     

       378
       378
       +
               })

     

       379
       379
       +
             );

     

       380
       380
       +
           };

     

       381
       381
       +
       

     

       382
       382
       +
           const iterable = sinks.toAsyncIterable(source);

     

       383
       383
       +
           for await (const value of iterable) {

     

       384
       384
       +
             expect(value).toBe(0);

     

       385
       385
       +
             break;

     

       386
       386
       +
           }

     

       387
       387
       +
       

     

       388
       388
       +
           expect(closed).toBe(true);

     

       389
       389
       +
         });

     

       390
       390
       +
       });

     

       391
       391
       +
       

     

       232
       392
        
       describe('toObservable', () => {

     

       233
       393
        
         it('creates an Observable mirroring the Wonka source', () => {

     

       234
       394
        
           const next = vi.fn();

+46

src/sinks.ts

···

       38
       38
        
         })(source);

     

       39
       39
        
       }

     

       40
       40
        
       

     

       41
       41
       +
       const doneResult = { done: true } as IteratorReturnResult<void>;

     

       42
       42
       +
       

     

       43
       43
       +
       export const toAsyncIterable = <T>(source: Source<T>): AsyncIterable<T> => ({

     

       44
       44
       +
         [Symbol.asyncIterator](): AsyncIterator<T> {

     

       45
       45
       +
           const buffer: T[] = [];

     

       46
       46
       +
       

     

       47
       47
       +
           let ended = false;

     

       48
       48
       +
           let talkback = talkbackPlaceholder;

     

       49
       49
       +
           let next: ((value: IteratorResult<T>) => void) | void;

     

       50
       50
       +
       

     

       51
       51
       +
           source(signal => {

     

       52
       52
       +
             if (ended) {

     

       53
       53
       +
               /*noop*/

     

       54
       54
       +
             } else if (signal === SignalKind.End) {

     

       55
       55
       +
               if (next) next = next(doneResult);

     

       56
       56
       +
               ended = true;

     

       57
       57
       +
             } else if (signal.tag === SignalKind.Start) {

     

       58
       58
       +
               (talkback = signal[0])(TalkbackKind.Pull);

     

       59
       59
       +
             } else if (next) {

     

       60
       60
       +
               next = next({ value: signal[0], done: false });

     

       61
       61
       +
             } else {

     

       62
       62
       +
               buffer.push(signal[0]);

     

       63
       63
       +
             }

     

       64
       64
       +
           });

     

       65
       65
       +
       

     

       66
       66
       +
           return {

     

       67
       67
       +
             async next(): Promise<IteratorResult<T>> {

     

       68
       68
       +
               if (ended && !buffer.length) {

     

       69
       69
       +
                 return doneResult;

     

       70
       70
       +
               } else if (!ended && buffer.length <= 1) {

     

       71
       71
       +
                 talkback(TalkbackKind.Pull);

     

       72
       72
       +
               }

     

       73
       73
       +
       

     

       74
       74
       +
               return buffer.length

     

       75
       75
       +
                 ? { value: buffer.shift()!, done: false }

     

       76
       76
       +
                 : new Promise(resolve => (next = resolve));

     

       77
       77
       +
             },

     

       78
       78
       +
             async return(): Promise<IteratorReturnResult<void>> {

     

       79
       79
       +
               if (!ended) next = talkback(TalkbackKind.Close);

     

       80
       80
       +
               ended = true;

     

       81
       81
       +
               return doneResult;

     

       82
       82
       +
             },

     

       83
       83
       +
           };

     

       84
       84
       +
         },

     

       85
       85
       +
       });

     

       86
       86
       +
       

     

       41
       87
        
       export function toArray<T>(source: Source<T>): T[] {

     

       42
       88
        
         const values: T[] = [];

     

       43
       89
        
         let talkback = talkbackPlaceholder;