commit a4e79fe36095ec9aef034057f0b9d933ee4f35de · kitten.sh/wonka

+2 -2

gatsby-config.js

···

       3
        
           title: 'Wonka',

     

       4
        
           description: 'A fast push & pull stream library for Reason, OCaml, and TypeScript',

     

       5
        
           siteUrl: 'https://wonka.kitten.sh',

     

       6
       -
           githubUrl: 'https://github.com/kitten/wonka'

     

       7
        
         },

     

       8
        
         plugins: ['gatsby-plugin-netlify'],

     

       9
       -
         __experimentalThemes: ['gatsby-theme-docs-system']

     

       10
        
       };

···

       3
        
           title: 'Wonka',

     

       4
        
           description: 'A fast push & pull stream library for Reason, OCaml, and TypeScript',

     

       5
        
           siteUrl: 'https://wonka.kitten.sh',

     

       6
       +
           githubUrl: 'https://github.com/kitten/wonka',

     

       7
        
         },

     

       8
        
         plugins: ['gatsby-plugin-netlify'],

     

       9
       +
         __experimentalThemes: ['gatsby-theme-docs-system'],

     

       10
        
       };

+4 -4

gatsby/theme.js

···

       13
        
         'Apple Color Emoji',

     

       14
        
         'Segoe UI Emoji',

     

       15
        
         'Segoe UI Symbol',

     

       16
       -
         'Noto Color Emoji'

     

       17
        
       ];

     

       18
        
       

     

       19
        
       export const fonts = {

     

       20
        
         header: ['phantom-sans', ...systemFonts],

     

       21
        
         code: ['space-mono', 'monospace'],

     

       22
       -
         body: systemFonts

     

       23
        
       };

     

       24
        
       

     

       25
        
       export const colors = {

     
···

       29
        
         fg: '#36313d',

     

       30
        
         fgHeading: '#000000',

     

       31
        
         fgPassive: '#78757a',

     

       32
       -
         fgActive: '#f5735f'

     

       33
        
       };

     

       34
        
       

     

       35
        
       export const prismTheme = nightOwlLight;

     
···

       46
        
       export const borders = [

     

       47
        
         `${borderWidths[0]} solid ${colors.bgPassive}`,

     

       48
        
         `${borderWidths[1]} solid ${colors.bgPassive}`,

     

       49
       -
         `${borderWidths[2]} solid ${colors.bgPassive}`

     

       50
        
       ];

···

       13
        
         'Apple Color Emoji',

     

       14
        
         'Segoe UI Emoji',

     

       15
        
         'Segoe UI Symbol',

     

       16
       +
         'Noto Color Emoji',

     

       17
        
       ];

     

       18
        
       

     

       19
        
       export const fonts = {

     

       20
        
         header: ['phantom-sans', ...systemFonts],

     

       21
        
         code: ['space-mono', 'monospace'],

     

       22
       +
         body: systemFonts,

     

       23
        
       };

     

       24
        
       

     

       25
        
       export const colors = {

     
···

       29
        
         fg: '#36313d',

     

       30
        
         fgHeading: '#000000',

     

       31
        
         fgPassive: '#78757a',

     

       32
       +
         fgActive: '#f5735f',

     

       33
        
       };

     

       34
        
       

     

       35
        
       export const prismTheme = nightOwlLight;

     
···

       46
        
       export const borders = [

     

       47
        
         `${borderWidths[0]} solid ${colors.bgPassive}`,

     

       48
        
         `${borderWidths[1]} solid ${colors.bgPassive}`,

     

       49
       +
         `${borderWidths[2]} solid ${colors.bgPassive}`,

     

       50
        
       ];

+1 -1

gatsby/typography.js

···

       9
        
         headerFontFamily: theme.fonts.header,

     

       10
        
         headerWeight: '500',

     

       11
        
         bodyFontFamily: theme.fonts.body,

     

       12
       -
         bodyWeight: '400'

     

       13
        
       });

     

       14
        
       

     

       15
        
       export default typography;

···

       9
        
         headerFontFamily: theme.fonts.header,

     

       10
        
         headerWeight: '500',

     

       11
        
         bodyFontFamily: theme.fonts.body,

     

       12
       +
         bodyWeight: '400',

     

       13
        
       });

     

       14
        
       

     

       15
        
       export default typography;

+7 -13

rollup.config.js

···

       22
        
       

     

       23
        
         typescript({

     

       24
        
           typescript: require('typescript'),

     

       25
       -
           exclude: [

     

       26
       -
             'src/**/*.test.ts',

     

       27
       -
             '**/__tests__/*',

     

       28
       -
           ],

     

       29
        
           compilerOptions: {

     

       30
        
             sourceMap: true,

     

       31
        
             noEmit: false,

     
···

       49
        
             templateString: false,

     

       50
        
             objectRestSpread: false,

     

       51
        
           },

     

       52
       -
           exclude: 'node_modules/**'

     

       53
        
         }),

     

       54
        
       

     

       55
        
         terser({

     
···

       68
        
             sequences: false,

     

       69
        
             loops: false,

     

       70
        
             conditionals: false,

     

       71
       -
             join_vars: false

     

       72
        
           },

     

       73
        
           mangle: {

     

       74
        
             module: true,

     
···

       77
        
           output: {

     

       78
        
             beautify: true,

     

       79
        
             braces: true,

     

       80
       -
             indent_level: 2

     

       81
       -
           }

     

       82
        
         }),

     

       83
        
       ];

     

       84
        
       

     

       85
       -
       const output = (format) => {

     

       86
        
         const extension = format === 'esm' ? '.mjs' : '.js';

     

       87
        
         return {

     

       88
        
           chunkFileNames: '[hash]' + extension,

     
···

       119
        
           tryCatchDeoptimization: false,

     

       120
        
           moduleSideEffects: false,

     

       121
        
         },

     

       122
       -
         output: [

     

       123
       -
           output('esm'),

     

       124
       -
           output('cjs'),

     

       125
       -
         ],

     

       126
        
       };

     

       127
        
       

     

       128
        
       export default config;

···

       22
        
       

     

       23
        
         typescript({

     

       24
        
           typescript: require('typescript'),

     

       25
       +
           exclude: ['src/**/*.test.ts', '**/__tests__/*'],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       26
        
           compilerOptions: {

     

       27
        
             sourceMap: true,

     

       28
        
             noEmit: false,

     
···

       46
        
             templateString: false,

     

       47
        
             objectRestSpread: false,

     

       48
        
           },

     

       49
       +
           exclude: 'node_modules/**',

     

       50
        
         }),

     

       51
        
       

     

       52
        
         terser({

     
···

       65
        
             sequences: false,

     

       66
        
             loops: false,

     

       67
        
             conditionals: false,

     

       68
       +
             join_vars: false,

     

       69
        
           },

     

       70
        
           mangle: {

     

       71
        
             module: true,

     
···

       74
        
           output: {

     

       75
        
             beautify: true,

     

       76
        
             braces: true,

     

       77
       +
             indent_level: 2,

     

       78
       +
           },

     

       79
        
         }),

     

       80
        
       ];

     

       81
        
       

     

       82
       +
       const output = format => {

     

       83
        
         const extension = format === 'esm' ? '.mjs' : '.js';

     

       84
        
         return {

     

       85
        
           chunkFileNames: '[hash]' + extension,

     
···

       116
        
           tryCatchDeoptimization: false,

     

       117
        
           moduleSideEffects: false,

     

       118
        
         },

     

       119
       +
         output: [output('esm'), output('cjs')],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       120
        
       };

     

       121
        
       

     

       122
        
       export default config;

+4 -6

scripts/eslint-preset.js

···

       13
        
           'sort-keys': 'off',

     

       14
        
           'no-console': ['error', { allow: ['warn', 'error'] }],

     

       15
        
           'prefer-arrow/prefer-arrow-functions': 'off',

     

       0
        
       
     

       16
        
       

     

       17
        
           'prettier/prettier': [

     

       18
        
             'error',

     
···

       55
        
               '@typescript-eslint/no-misused-new': 'off',

     

       56
        
               '@typescript-eslint/no-explicit-any': 'off',

     

       57
        
               '@typescript-eslint/array-type': 'off',

     

       58
       -
               '@typescript-eslint/no-unused-vars': [

     

       59
       -
                 'error',

     

       60
       -
                 {

     

       61
       -
                   argsIgnorePattern: '^_',

     

       62
       -
                 },

     

       63
       -
               ],

     

       64
        
             },

     

       65
        
           },

     

       66
        
         ],

···

       13
        
           'sort-keys': 'off',

     

       14
        
           'no-console': ['error', { allow: ['warn', 'error'] }],

     

       15
        
           'prefer-arrow/prefer-arrow-functions': 'off',

     

       16
       +
           'prefer-rest-params': 'off',

     

       17
        
       

     

       18
        
           'prettier/prettier': [

     

       19
        
             'error',

     
···

       56
        
               '@typescript-eslint/no-misused-new': 'off',

     

       57
        
               '@typescript-eslint/no-explicit-any': 'off',

     

       58
        
               '@typescript-eslint/array-type': 'off',

     

       59
       +
               '@typescript-eslint/no-empty-function': 'off',

     

       60
       +
               '@typescript-eslint/no-unused-vars': 'off',

     

       61
       +
               'prefer-rest-params': 'off',

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       62
        
             },

     

       63
        
           },

     

       64
        
         ],

+2 -2

scripts/flow-typings-plugin.js

···

       5
        
       

     

       6
        
       function flowTypings() {

     

       7
        
         return {

     

       8
       -
           name: "flow-typings",

     

       9
        
           async writeBundle() {

     

       10
        
             const cwd = process.cwd();

     

       11
        
             for (const file of glob('dist/types/**/*.d.ts')) {

     
···

       17
        
               const definition = flowdef.replace(/import/g, 'import type');

     

       18
        
               writeFileSync(newpath, '// @flow\n\n' + definition);

     

       19
        
             }

     

       20
       -
           }

     

       21
        
         };

     

       22
        
       }

     

       23

···

       5
        
       

     

       6
        
       function flowTypings() {

     

       7
        
         return {

     

       8
       +
           name: 'flow-typings',

     

       9
        
           async writeBundle() {

     

       10
        
             const cwd = process.cwd();

     

       11
        
             for (const file of glob('dist/types/**/*.d.ts')) {

     
···

       17
        
               const definition = flowdef.replace(/import/g, 'import type');

     

       18
        
               writeFileSync(newpath, '// @flow\n\n' + definition);

     

       19
        
             }

     

       20
       +
           },

     

       21
        
         };

     

       22
        
       }

     

       23

+122 -164

src/__tests__/operators.test.ts

···

       9
        
         A Pull will be sent from the sink upwards and should pass through

     

       10
        
         the operator until the source receives it, which then pushes a

     

       11
        
         value down. */

     

       12
       -
       const passesPassivePull = (

     

       13
       -
         operator: Operator<any, any>,

     

       14
       -
         output: any = 0

     

       15
       -
       ) => {

     

       16
        
         it('responds to Pull talkback signals (spec)', () => {

     

       17
        
           let talkback: TalkbackFn | null = null;

     

       18
        
           let pushes = 0;

     

       19
        
           const values: any[] = [];

     

       20
        
       

     

       21
        
           const source: Source<any> = sink => {

     

       22
       -
             sink(start((signal) => {

     

       23
       -
               if (!pushes && signal === TalkbackKind.Pull) {

     

       24
       -
                 pushes++;

     

       25
       -
                 sink(push(0));

     

       26
       -
               }

     

       27
       -
             }));

     

       0
        
       
     

       0
        
       
     

       28
        
           };

     

       29
        
       

     

       30
       -
           const sink: Sink<any> = (signal) => {

     

       31
        
             expect(signal).not.toBe(SignalKind.End);

     

       32
        
             if (signal === SignalKind.End) {

     

       33
        
               /*noop*/

     
···

       55
        
         A Push will be sent downwards from the source, through the

     

       56
        
         operator to the sink. Pull events should be let through from

     

       57
        
         the sink after every Push event. */

     

       58
       -
       const passesActivePush = (

     

       59
       -
         operator: Operator<any, any>,

     

       60
       -
         result: any = 0

     

       61
       -
       ) => {

     

       62
        
         it('responds to eager Push signals (spec)', () => {

     

       63
        
           const values: any[] = [];

     

       64
        
           let talkback: TalkbackFn | null = null;

     

       65
        
           let sink: Sink<any> | null = null;

     

       66
        
           let pulls = 0;

     

       67
        
       

     

       68
       -
           const source: Source<any> = (_sink) => {

     

       69
       -
             (sink = _sink)(start((signal) => {

     

       70
       -
               if (signal === TalkbackKind.Pull)

     

       71
       -
                 pulls++;

     

       72
       -
             }));

     

       0
        
       
     

       73
        
           };

     

       74
        
       

     

       75
       -
           operator(source)((signal) => {

     

       76
        
             expect(signal).not.toBe(SignalKind.End);

     

       77
        
             if (signal === SignalKind.End) {

     

       78
        
               /*noop*/

     
···

       105
        
           let closing = 0;

     

       106
        
       

     

       107
        
           const source: Source<any> = sink => {

     

       108
       -
             sink(start((signal) => {

     

       109
       -
               if (signal === TalkbackKind.Pull && !closing) {

     

       110
       -
                 sink(push(0));

     

       111
       -
               } else if (signal === TalkbackKind.Close) {

     

       112
       -
                 closing++;

     

       113
       -
               }

     

       114
       -
             }));

     

       0
        
       
     

       0
        
       
     

       115
        
           };

     

       116
        
       

     

       117
        
           const sink: Sink<any> = signal => {

     
···

       138
        
         A Push and End signal will be sent after the first Pull talkback

     

       139
        
         signal from the sink, which shouldn't lead to any extra Close or Pull

     

       140
        
         talkback signals. */

     

       141
       -
       const passesSourceEnd = (

     

       142
       -
         operator: Operator<any, any>,

     

       143
       -
         result: any = 0

     

       144
       -
       ) => {

     

       145
        
         it('passes on immediate Push then End signals from source (spec)', () => {

     

       146
        
           const signals: Signal<any>[] = [];

     

       147
        
           let talkback: TalkbackFn | null = null;

     
···

       149
        
           let ending = 0;

     

       150
        
       

     

       151
        
           const source: Source<any> = sink => {

     

       152
       -
             sink(start((signal) => {

     

       153
       -
               expect(signal).not.toBe(TalkbackKind.Close);

     

       154
       -
               if (signal === TalkbackKind.Pull) {

     

       155
       -
                 pulls++;

     

       156
       -
                 if (pulls === 1) {

     

       157
       -
                   sink(push(0));

     

       158
       -
                   sink(SignalKind.End);

     

       0
        
       
     

       0
        
       
     

       159
        
                 }

     

       160
       -
               }

     

       161
       -
             }));

     

       162
        
           };

     

       163
        
       

     

       164
        
           const sink: Sink<any> = signal => {

     
···

       188
        
         after the first pull in response to another.

     

       189
        
         This is similar to passesSourceEnd but more well behaved since

     

       190
        
         mergeMap/switchMap/concatMap are eager operators. */

     

       191
       -
       const passesSourcePushThenEnd = (

     

       192
       -
         operator: Operator<any, any>,

     

       193
       -
         result: any = 0

     

       194
       -
       ) => {

     

       195
        
         it('passes on End signals from source (spec)', () => {

     

       196
        
           const signals: Signal<any>[] = [];

     

       197
        
           let talkback: TalkbackFn | null = null;

     
···

       199
        
           let ending = 0;

     

       200
        
       

     

       201
        
           const source: Source<any> = sink => {

     

       202
       -
             sink(start((signal) => {

     

       203
       -
               expect(signal).not.toBe(TalkbackKind.Close);

     

       204
       -
               if (signal === TalkbackKind.Pull) {

     

       205
       -
                 pulls++;

     

       206
       -
                 if (pulls <= 2) { sink(push(0)); }

     

       207
       -
                 else { sink(SignalKind.End); }

     

       208
       -
               }

     

       209
       -
             }));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       210
        
           };

     

       211
        
       

     

       212
        
           const sink: Sink<any> = signal => {

     
···

       228
        
           jest.runAllTimers();

     

       229
        
           expect(ending).toBe(1);

     

       230
        
           expect(pulls).toBe(3);

     

       231
       -
           expect(signals).toEqual([

     

       232
       -
             push(result),

     

       233
       -
             push(result),

     

       234
       -
             SignalKind.End

     

       235
       -
           ]);

     

       236
        
         });

     

       237
        
       };

     

       238
        
       

     
···

       272
        
           const signals: Signal<any>[] = [];

     

       273
        
       

     

       274
        
           const source: Source<any> = sink => {

     

       275
       -
             sink(start((signal) => {

     

       276
       -
               if (signal === TalkbackKind.Pull) {

     

       277
       -
                 pulls++;

     

       278
       -
                 sink(SignalKind.End);

     

       279
       -
                 sink(push(123));

     

       280
       -
               }

     

       281
       -
             }));

     

       0
        
       
     

       0
        
       
     

       282
        
           };

     

       283
        
       

     

       284
        
           const sink: Sink<any> = signal => {

     
···

       303
        
           const signals: Signal<any>[] = [];

     

       304
        
       

     

       305
        
           const source: Source<any> = sink => {

     

       306
       -
             sink(start((signal) => {

     

       307
       -
               if (signal === TalkbackKind.Close) {

     

       308
       -
                 sink(push(123));

     

       309
       -
               }

     

       310
       -
             }));

     

       0
        
       
     

       0
        
       
     

       311
        
           };

     

       312
        
       

     

       313
        
           const sink: Sink<any> = signal => {

     
···

       339
        
           let ending = 0;

     

       340
        
       

     

       341
        
           const source: Source<any> = sink => {

     

       342
       -
             sink(start((signal) => {

     

       343
       -
               // For some operator tests we do need to send a single value

     

       344
       -
               if (signal === TalkbackKind.Pull) {

     

       345
       -
                 sink(push(null));

     

       346
       -
               } else {

     

       347
       -
                 closing++;

     

       348
       -
               }

     

       349
       -
             }));

     

       0
        
       
     

       0
        
       
     

       350
        
           };

     

       351
        
       

     

       352
        
           const sink: Sink<any> = signal => {

     
···

       364
        
         });

     

       365
        
       };

     

       366
        
       

     

       367
       -
       const passesAsyncSequence = (

     

       368
       -
         operator: Operator<any, any>,

     

       369
       -
         result: any = 0

     

       370
       -
       ) => {

     

       371
        
         it('passes an async push with an async end (spec)', () => {

     

       372
        
           let hasPushed = false;

     

       373
        
           const signals: Signal<any>[] = [];

     

       374
        
       

     

       375
        
           const source: Source<any> = sink => {

     

       376
       -
             sink(start((signal) => {

     

       377
       -
               if (signal === TalkbackKind.Pull && !hasPushed) {

     

       378
       -
                 hasPushed = true;

     

       379
       -
                 setTimeout(() => sink(push(0)), 10);

     

       380
       -
                 setTimeout(() => sink(SignalKind.End), 20);

     

       381
       -
               }

     

       382
       -
             }));

     

       0
        
       
     

       0
        
       
     

       383
        
           };

     

       384
        
       

     

       385
        
           const sink: Sink<any> = signal => {

     
···

       402
        
           expect(hasPushed).toBeTruthy();

     

       403
        
           jest.runAllTimers();

     

       404
        
       

     

       405
       -
           expect(signals).toEqual([

     

       406
       -
             push(result),

     

       407
       -
             SignalKind.End

     

       408
       -
           ]);

     

       409
        
         });

     

       410
        
       };

     

       411
        
       

     
···

       439
        
       

     

       440
        
       describe('buffer', () => {

     

       441
        
         const valueThenNever: Source<any> = sink =>

     

       442
       -
           sink(start((signal) => {

     

       443
       -
             if (signal === TalkbackKind.Pull)

     

       444
       -
               sink(push(null));

     

       445
       -
           }));

     

       0
        
       
     

       446
        
       

     

       447
        
         const noop = operators.buffer(valueThenNever);

     

       448
        
       

     
···

       522
        
           })(sources.fromValue(null))(fn);

     

       523
        
       

     

       524
        
           expect(teardown).toHaveBeenCalled();

     

       525
       -
           expect(signals).toEqual([

     

       526
       -
             start(expect.any(Function)),

     

       527
       -
           ]);

     

       528
        
         });

     

       529
        
       

     

       530
        
         // This asynchronous test for concatMap will behave differently than mergeMap & switchMap

     
···

       539
        
           );

     

       540
        
       

     

       541
        
           jest.advanceTimersByTime(14);

     

       542
       -
           expect(fn.mock.calls).toEqual([

     

       543
       -
             [1],

     

       544
       -
             [2],

     

       545
       -
           ]);

     

       546
        
       

     

       547
        
           jest.runAllTimers();

     

       548
       -
           expect(fn.mock.calls).toEqual([

     

       549
       -
             [1],

     

       550
       -
             [2],

     

       551
       -
             [10],

     

       552
       -
             [20],

     

       553
       -
           ]);

     

       554
        
         });

     

       555
        
       

     

       556
        
         it('works for fully asynchronous sources', () => {

     
···

       561
        
               return sources.make(observer => {

     

       562
        
                 setTimeout(() => observer.next(1));

     

       563
        
                 return () => {};

     

       564
       -
               })

     

       565
        
             })(sources.fromValue(null))

     

       566
        
           );

     

       567
        
       

     
···

       573
        
           const values: any[] = [];

     

       574
        
       

     

       575
        
           sinks.forEach(x => values.push(x))(

     

       576
       -
             operators.concat([

     

       577
       -
               sources.fromArray([1, 2]),

     

       578
       -
               sources.fromArray([3, 4])

     

       579
       -
             ])

     

       580
        
           );

     

       581
        
       

     

       582
       -
           expect(values).toEqual([ 1, 2, 3, 4 ]);

     

       583
        
         });

     

       584
        
       });

     

       585
        
       

     
···

       738
        
           })(sources.fromValue(null))(fn);

     

       739
        
       

     

       740
        
           expect(teardown).toHaveBeenCalled();

     

       741
       -
           expect(values).toEqual([

     

       742
       -
             start(expect.any(Function)),

     

       743
       -
           ]);

     

       744
        
         });

     

       745
        
       

     

       746
        
         // This asynchronous test for mergeMap will behave differently than concatMap & switchMap

     
···

       755
        
           );

     

       756
        
       

     

       757
        
           jest.runAllTimers();

     

       758
       -
           expect(fn.mock.calls).toEqual([

     

       759
       -
             [1],

     

       760
       -
             [10],

     

       761
       -
             [2],

     

       762
       -
             [20],

     

       763
       -
           ]);

     

       764
        
         });

     

       765
        
       

     

       766
        
         it('emits synchronous values in order', () => {

     

       767
        
           const values: any[] = [];

     

       768
        
       

     

       769
        
           sinks.forEach(x => values.push(x))(

     

       770
       -
             operators.merge([

     

       771
       -
               sources.fromArray([1, 2]),

     

       772
       -
               sources.fromArray([3, 4])

     

       773
       -
             ])

     

       774
        
           );

     

       775
        
       

     

       776
       -
           expect(values).toEqual([ 1, 2, 3, 4 ]);

     

       777
        
         });

     

       778
        
       });

     

       779
        
       

     
···

       841
        
           let sink: Sink<any>;

     

       842
        
       

     

       843
        
           const fn = jest.fn();

     

       844
       -
           const source: Source<any> = _sink => { sink = _sink; };

     

       0
        
       
     

       0
        
       
     

       845
        
       

     

       846
        
           sinks.forEach(() => {})(operators.onStart(fn)(source));

     

       847
        
       

     
···

       854
        
       

     

       855
        
       describe('sample', () => {

     

       856
        
         const valueThenNever: Source<any> = sink =>

     

       857
       -
           sink(start((signal) => {

     

       858
       -
             if (signal === TalkbackKind.Pull)

     

       859
       -
               sink(push(null));

     

       860
       -
           }));

     

       0
        
       
     

       861
        
       

     

       862
        
         const noop = operators.sample(valueThenNever);

     

       863
        
       

     
···

       1059
        
           })(sources.fromValue(null))(fn);

     

       1060
        
       

     

       1061
        
           expect(teardown).toHaveBeenCalled();

     

       1062
       -
           expect(signals).toEqual([

     

       1063
       -
             start(expect.any(Function)),

     

       1064
       -
           ]);

     

       1065
        
         });

     

       1066
        
       

     

       1067
        
         // This asynchronous test for switchMap will behave differently than concatMap & mergeMap

     
···

       1070
        
           const fn = jest.fn();

     

       1071
        
       

     

       1072
        
           sinks.forEach(fn)(

     

       1073
       -
             operators.switchMap((x: number) => (

     

       1074
        
               operators.take(2)(operators.map((y: number) => x * (y + 1))(sources.interval(5)))

     

       1075
       -
             ))(source)

     

       1076
        
           );

     

       1077
        
       

     

       1078
        
           jest.runAllTimers();

     

       1079
       -
           expect(fn.mock.calls).toEqual([

     

       1080
       -
             [1],

     

       1081
       -
             [10],

     

       1082
       -
             [20],

     

       1083
       -
           ]);

     

       1084
        
         });

     

       1085
        
       });

     

       1086
        
       

     
···

       1104
        
           next(1);

     

       1105
        
       

     

       1106
        
           expect(fn).toHaveBeenCalledTimes(3);

     

       1107
       -
           expect(fn.mock.calls).toEqual([

     

       1108
       -
             [start(expect.any(Function))],

     

       1109
       -
             [push(1)],

     

       1110
       -
             [SignalKind.End],

     

       1111
       -
           ]);

     

       1112
        
         });

     

       1113
        
       });

     

       1114
        
       

     
···

       1134
        
           next(1);

     

       1135
        
       

     

       1136
        
           expect(fn).toHaveBeenCalledTimes(2);

     

       1137
       -
           expect(fn.mock.calls).toEqual([

     

       1138
       -
             [start(expect.any(Function))],

     

       1139
       -
             [push(1)],

     

       1140
       -
           ]);

     

       1141
        
       

     

       1142
        
           notify(null);

     

       1143
        
           expect(fn).toHaveBeenCalledTimes(3);

     
···

       1165
        
           next(1);

     

       1166
        
           next(2);

     

       1167
        
       

     

       1168
       -
           expect(fn.mock.calls).toEqual([

     

       1169
       -
             [start(expect.any(Function))],

     

       1170
       -
             [push(1)],

     

       1171
       -
             [SignalKind.End],

     

       1172
       -
           ]);

     

       1173
        
         });

     

       1174
        
       });

     

       1175
        
       

     
···

       1199
        
           expect(signals.length).toBe(0);

     

       1200
        
           complete();

     

       1201
        
       

     

       1202
       -
           expect(signals).toEqual([

     

       1203
       -
             start(expect.any(Function)),

     

       1204
       -
             push(2),

     

       1205
       -
             SignalKind.End,

     

       1206
       -
           ]);

     

       1207
        
         });

     

       1208
        
       });

     

       1209

···

       9
        
         A Pull will be sent from the sink upwards and should pass through

     

       10
        
         the operator until the source receives it, which then pushes a

     

       11
        
         value down. */

     

       12
       +
       const passesPassivePull = (operator: Operator<any, any>, output: any = 0) => {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
         it('responds to Pull talkback signals (spec)', () => {

     

       14
        
           let talkback: TalkbackFn | null = null;

     

       15
        
           let pushes = 0;

     

       16
        
           const values: any[] = [];

     

       17
        
       

     

       18
        
           const source: Source<any> = sink => {

     

       19
       +
             sink(

     

       20
       +
               start(signal => {

     

       21
       +
                 if (!pushes && signal === TalkbackKind.Pull) {

     

       22
       +
                   pushes++;

     

       23
       +
                   sink(push(0));

     

       24
       +
                 }

     

       25
       +
               })

     

       26
       +
             );

     

       27
        
           };

     

       28
        
       

     

       29
       +
           const sink: Sink<any> = signal => {

     

       30
        
             expect(signal).not.toBe(SignalKind.End);

     

       31
        
             if (signal === SignalKind.End) {

     

       32
        
               /*noop*/

     
···

       54
        
         A Push will be sent downwards from the source, through the

     

       55
        
         operator to the sink. Pull events should be let through from

     

       56
        
         the sink after every Push event. */

     

       57
       +
       const passesActivePush = (operator: Operator<any, any>, result: any = 0) => {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       58
        
         it('responds to eager Push signals (spec)', () => {

     

       59
        
           const values: any[] = [];

     

       60
        
           let talkback: TalkbackFn | null = null;

     

       61
        
           let sink: Sink<any> | null = null;

     

       62
        
           let pulls = 0;

     

       63
        
       

     

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

     

       65
       +
             (sink = _sink)(

     

       66
       +
               start(signal => {

     

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

     

       68
       +
               })

     

       69
       +
             );

     

       70
        
           };

     

       71
        
       

     

       72
       +
           operator(source)(signal => {

     

       73
        
             expect(signal).not.toBe(SignalKind.End);

     

       74
        
             if (signal === SignalKind.End) {

     

       75
        
               /*noop*/

     
···

       102
        
           let closing = 0;

     

       103
        
       

     

       104
        
           const source: Source<any> = sink => {

     

       105
       +
             sink(

     

       106
       +
               start(signal => {

     

       107
       +
                 if (signal === TalkbackKind.Pull && !closing) {

     

       108
       +
                   sink(push(0));

     

       109
       +
                 } else if (signal === TalkbackKind.Close) {

     

       110
       +
                   closing++;

     

       111
       +
                 }

     

       112
       +
               })

     

       113
       +
             );

     

       114
        
           };

     

       115
        
       

     

       116
        
           const sink: Sink<any> = signal => {

     
···

       137
        
         A Push and End signal will be sent after the first Pull talkback

     

       138
        
         signal from the sink, which shouldn't lead to any extra Close or Pull

     

       139
        
         talkback signals. */

     

       140
       +
       const passesSourceEnd = (operator: Operator<any, any>, result: any = 0) => {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       141
        
         it('passes on immediate Push then End signals from source (spec)', () => {

     

       142
        
           const signals: Signal<any>[] = [];

     

       143
        
           let talkback: TalkbackFn | null = null;

     
···

       145
        
           let ending = 0;

     

       146
        
       

     

       147
        
           const source: Source<any> = sink => {

     

       148
       +
             sink(

     

       149
       +
               start(signal => {

     

       150
       +
                 expect(signal).not.toBe(TalkbackKind.Close);

     

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

     

       152
       +
                   pulls++;

     

       153
       +
                   if (pulls === 1) {

     

       154
       +
                     sink(push(0));

     

       155
       +
                     sink(SignalKind.End);

     

       156
       +
                   }

     

       157
        
                 }

     

       158
       +
               })

     

       159
       +
             );

     

       160
        
           };

     

       161
        
       

     

       162
        
           const sink: Sink<any> = signal => {

     
···

       186
        
         after the first pull in response to another.

     

       187
        
         This is similar to passesSourceEnd but more well behaved since

     

       188
        
         mergeMap/switchMap/concatMap are eager operators. */

     

       189
       +
       const passesSourcePushThenEnd = (operator: Operator<any, any>, result: any = 0) => {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       190
        
         it('passes on End signals from source (spec)', () => {

     

       191
        
           const signals: Signal<any>[] = [];

     

       192
        
           let talkback: TalkbackFn | null = null;

     
···

       194
        
           let ending = 0;

     

       195
        
       

     

       196
        
           const source: Source<any> = sink => {

     

       197
       +
             sink(

     

       198
       +
               start(signal => {

     

       199
       +
                 expect(signal).not.toBe(TalkbackKind.Close);

     

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

     

       201
       +
                   pulls++;

     

       202
       +
                   if (pulls <= 2) {

     

       203
       +
                     sink(push(0));

     

       204
       +
                   } else {

     

       205
       +
                     sink(SignalKind.End);

     

       206
       +
                   }

     

       207
       +
                 }

     

       208
       +
               })

     

       209
       +
             );

     

       210
        
           };

     

       211
        
       

     

       212
        
           const sink: Sink<any> = signal => {

     
···

       228
        
           jest.runAllTimers();

     

       229
        
           expect(ending).toBe(1);

     

       230
        
           expect(pulls).toBe(3);

     

       231
       +
           expect(signals).toEqual([push(result), push(result), SignalKind.End]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       232
        
         });

     

       233
        
       };

     

       234
        
       

     
···

       268
        
           const signals: Signal<any>[] = [];

     

       269
        
       

     

       270
        
           const source: Source<any> = sink => {

     

       271
       +
             sink(

     

       272
       +
               start(signal => {

     

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

     

       274
       +
                   pulls++;

     

       275
       +
                   sink(SignalKind.End);

     

       276
       +
                   sink(push(123));

     

       277
       +
                 }

     

       278
       +
               })

     

       279
       +
             );

     

       280
        
           };

     

       281
        
       

     

       282
        
           const sink: Sink<any> = signal => {

     
···

       301
        
           const signals: Signal<any>[] = [];

     

       302
        
       

     

       303
        
           const source: Source<any> = sink => {

     

       304
       +
             sink(

     

       305
       +
               start(signal => {

     

       306
       +
                 if (signal === TalkbackKind.Close) {

     

       307
       +
                   sink(push(123));

     

       308
       +
                 }

     

       309
       +
               })

     

       310
       +
             );

     

       311
        
           };

     

       312
        
       

     

       313
        
           const sink: Sink<any> = signal => {

     
···

       339
        
           let ending = 0;

     

       340
        
       

     

       341
        
           const source: Source<any> = sink => {

     

       342
       +
             sink(

     

       343
       +
               start(signal => {

     

       344
       +
                 // For some operator tests we do need to send a single value

     

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

     

       346
       +
                   sink(push(null));

     

       347
       +
                 } else {

     

       348
       +
                   closing++;

     

       349
       +
                 }

     

       350
       +
               })

     

       351
       +
             );

     

       352
        
           };

     

       353
        
       

     

       354
        
           const sink: Sink<any> = signal => {

     
···

       366
        
         });

     

       367
        
       };

     

       368
        
       

     

       369
       +
       const passesAsyncSequence = (operator: Operator<any, any>, result: any = 0) => {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       370
        
         it('passes an async push with an async end (spec)', () => {

     

       371
        
           let hasPushed = false;

     

       372
        
           const signals: Signal<any>[] = [];

     

       373
        
       

     

       374
        
           const source: Source<any> = sink => {

     

       375
       +
             sink(

     

       376
       +
               start(signal => {

     

       377
       +
                 if (signal === TalkbackKind.Pull && !hasPushed) {

     

       378
       +
                   hasPushed = true;

     

       379
       +
                   setTimeout(() => sink(push(0)), 10);

     

       380
       +
                   setTimeout(() => sink(SignalKind.End), 20);

     

       381
       +
                 }

     

       382
       +
               })

     

       383
       +
             );

     

       384
        
           };

     

       385
        
       

     

       386
        
           const sink: Sink<any> = signal => {

     
···

       403
        
           expect(hasPushed).toBeTruthy();

     

       404
        
           jest.runAllTimers();

     

       405
        
       

     

       406
       +
           expect(signals).toEqual([push(result), SignalKind.End]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       407
        
         });

     

       408
        
       };

     

       409
        
       

     
···

       437
        
       

     

       438
        
       describe('buffer', () => {

     

       439
        
         const valueThenNever: Source<any> = sink =>

     

       440
       +
           sink(

     

       441
       +
             start(signal => {

     

       442
       +
               if (signal === TalkbackKind.Pull) sink(push(null));

     

       443
       +
             })

     

       444
       +
           );

     

       445
        
       

     

       446
        
         const noop = operators.buffer(valueThenNever);

     

       447
        
       

     
···

       521
        
           })(sources.fromValue(null))(fn);

     

       522
        
       

     

       523
        
           expect(teardown).toHaveBeenCalled();

     

       524
       +
           expect(signals).toEqual([start(expect.any(Function))]);

     

       0
        
       
     

       0
        
       
     

       525
        
         });

     

       526
        
       

     

       527
        
         // This asynchronous test for concatMap will behave differently than mergeMap & switchMap

     
···

       536
        
           );

     

       537
        
       

     

       538
        
           jest.advanceTimersByTime(14);

     

       539
       +
           expect(fn.mock.calls).toEqual([[1], [2]]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       540
        
       

     

       541
        
           jest.runAllTimers();

     

       542
       +
           expect(fn.mock.calls).toEqual([[1], [2], [10], [20]]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       543
        
         });

     

       544
        
       

     

       545
        
         it('works for fully asynchronous sources', () => {

     
···

       550
        
               return sources.make(observer => {

     

       551
        
                 setTimeout(() => observer.next(1));

     

       552
        
                 return () => {};

     

       553
       +
               });

     

       554
        
             })(sources.fromValue(null))

     

       555
        
           );

     

       556
        
       

     
···

       562
        
           const values: any[] = [];

     

       563
        
       

     

       564
        
           sinks.forEach(x => values.push(x))(

     

       565
       +
             operators.concat([sources.fromArray([1, 2]), sources.fromArray([3, 4])])

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       566
        
           );

     

       567
        
       

     

       568
       +
           expect(values).toEqual([1, 2, 3, 4]);

     

       569
        
         });

     

       570
        
       });

     

       571
        
       

     
···

       724
        
           })(sources.fromValue(null))(fn);

     

       725
        
       

     

       726
        
           expect(teardown).toHaveBeenCalled();

     

       727
       +
           expect(values).toEqual([start(expect.any(Function))]);

     

       0
        
       
     

       0
        
       
     

       728
        
         });

     

       729
        
       

     

       730
        
         // This asynchronous test for mergeMap will behave differently than concatMap & switchMap

     
···

       739
        
           );

     

       740
        
       

     

       741
        
           jest.runAllTimers();

     

       742
       +
           expect(fn.mock.calls).toEqual([[1], [10], [2], [20]]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       743
        
         });

     

       744
        
       

     

       745
        
         it('emits synchronous values in order', () => {

     

       746
        
           const values: any[] = [];

     

       747
        
       

     

       748
        
           sinks.forEach(x => values.push(x))(

     

       749
       +
             operators.merge([sources.fromArray([1, 2]), sources.fromArray([3, 4])])

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       750
        
           );

     

       751
        
       

     

       752
       +
           expect(values).toEqual([1, 2, 3, 4]);

     

       753
        
         });

     

       754
        
       });

     

       755
        
       

     
···

       817
        
           let sink: Sink<any>;

     

       818
        
       

     

       819
        
           const fn = jest.fn();

     

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

     

       821
       +
             sink = _sink;

     

       822
       +
           };

     

       823
        
       

     

       824
        
           sinks.forEach(() => {})(operators.onStart(fn)(source));

     

       825
        
       

     
···

       832
        
       

     

       833
        
       describe('sample', () => {

     

       834
        
         const valueThenNever: Source<any> = sink =>

     

       835
       +
           sink(

     

       836
       +
             start(signal => {

     

       837
       +
               if (signal === TalkbackKind.Pull) sink(push(null));

     

       838
       +
             })

     

       839
       +
           );

     

       840
        
       

     

       841
        
         const noop = operators.sample(valueThenNever);

     

       842
        
       

     
···

       1038
        
           })(sources.fromValue(null))(fn);

     

       1039
        
       

     

       1040
        
           expect(teardown).toHaveBeenCalled();

     

       1041
       +
           expect(signals).toEqual([start(expect.any(Function))]);

     

       0
        
       
     

       0
        
       
     

       1042
        
         });

     

       1043
        
       

     

       1044
        
         // This asynchronous test for switchMap will behave differently than concatMap & mergeMap

     
···

       1047
        
           const fn = jest.fn();

     

       1048
        
       

     

       1049
        
           sinks.forEach(fn)(

     

       1050
       +
             operators.switchMap((x: number) =>

     

       1051
        
               operators.take(2)(operators.map((y: number) => x * (y + 1))(sources.interval(5)))

     

       1052
       +
             )(source)

     

       1053
        
           );

     

       1054
        
       

     

       1055
        
           jest.runAllTimers();

     

       1056
       +
           expect(fn.mock.calls).toEqual([[1], [10], [20]]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1057
        
         });

     

       1058
        
       });

     

       1059
        
       

     
···

       1077
        
           next(1);

     

       1078
        
       

     

       1079
        
           expect(fn).toHaveBeenCalledTimes(3);

     

       1080
       +
           expect(fn.mock.calls).toEqual([[start(expect.any(Function))], [push(1)], [SignalKind.End]]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1081
        
         });

     

       1082
        
       });

     

       1083
        
       

     
···

       1103
        
           next(1);

     

       1104
        
       

     

       1105
        
           expect(fn).toHaveBeenCalledTimes(2);

     

       1106
       +
           expect(fn.mock.calls).toEqual([[start(expect.any(Function))], [push(1)]]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1107
        
       

     

       1108
        
           notify(null);

     

       1109
        
           expect(fn).toHaveBeenCalledTimes(3);

     
···

       1131
        
           next(1);

     

       1132
        
           next(2);

     

       1133
        
       

     

       1134
       +
           expect(fn.mock.calls).toEqual([[start(expect.any(Function))], [push(1)], [SignalKind.End]]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1135
        
         });

     

       1136
        
       });

     

       1137
        
       

     
···

       1161
        
           expect(signals.length).toBe(0);

     

       1162
        
           complete();

     

       1163
        
       

     

       1164
       +
           expect(signals).toEqual([start(expect.any(Function)), push(2), SignalKind.End]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1165
        
         });

     

       1166
        
       });

     

       1167

+121 -99

src/__tests__/sinks.test.ts

···

       15
        
           let pulls = 0;

     

       16
        
           const fn = jest.fn();

     

       17
        
       

     

       18
       -
           const source: Source<any> = (sink) => {

     

       19
       -
             sink(start((signal) => {

     

       20
       -
               if (signal === TalkbackKind.Pull) {

     

       21
       -
                 if (pulls < 3) {

     

       22
       -
                   pulls++;

     

       23
       -
                   sink(push(0));

     

       24
       -
                 } else {

     

       25
       -
                   sink(SignalKind.End);

     

       26
       -
                   expect(pulls).toBe(3);

     

       0
        
       
     

       0
        
       
     

       27
        
                 }

     

       28
       -
               }

     

       29
       -
             }));

     

       30
        
           };

     

       31
        
       

     

       32
        
           sinks.subscribe(fn)(source);

     
···

       38
        
           let pulls = 0;

     

       39
        
           let closing = 0;

     

       40
        
       

     

       41
       -
           const source: Source<any> = (sink) => {

     

       42
       -
             sink(start((signal) => {

     

       43
       -
               if (signal === TalkbackKind.Pull) {

     

       44
       -
                 if (!pulls) {

     

       45
       -
                   pulls++;

     

       46
       -
                   sink(push(0));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       47
        
                 }

     

       48
       -
               } else {

     

       49
       -
                 closing++;

     

       50
       -
               }

     

       51
       -
             }));

     

       52
        
           };

     

       53
        
       

     

       54
        
           const sub = sinks.subscribe(() => {})(source);

     
···

       62
        
           let pulls = 0;

     

       63
        
           let closing = 0;

     

       64
        
       

     

       65
       -
           const source: Source<any> = (sink) => {

     

       66
       -
             sink(start((signal) => {

     

       67
       -
               if (signal === TalkbackKind.Pull) {

     

       68
       -
                 pulls++;

     

       69
       -
                 sink(SignalKind.End);

     

       70
       -
               } else {

     

       71
       -
                 closing++;

     

       72
       -
               }

     

       73
       -
             }));

     

       0
        
       
     

       0
        
       
     

       74
        
           };

     

       75
        
       

     

       76
        
           const sub = sinks.subscribe(() => {})(source);

     
···

       81
        
       

     

       82
        
         it('ignores Push signals after the source has ended', () => {

     

       83
        
           const fn = jest.fn();

     

       84
       -
           const source: Source<any> = (sink) => {

     

       85
       -
             sink(start((signal) => {

     

       86
       -
               if (signal === TalkbackKind.Pull) {

     

       87
       -
                 sink(SignalKind.End);

     

       88
       -
                 sink(push(0));

     

       89
       -
               }

     

       90
       -
             }));

     

       0
        
       
     

       0
        
       
     

       91
        
           };

     

       92
        
       

     

       93
        
           sinks.subscribe(fn)(source);

     
···

       96
        
       

     

       97
        
         it('ignores Push signals after cancellation', () => {

     

       98
        
           const fn = jest.fn();

     

       99
       -
           const source: Source<any> = (sink) => {

     

       100
       -
             sink(start((signal) => {

     

       101
       -
               if (signal === TalkbackKind.Close) {

     

       102
       -
                 sink(push(0));

     

       103
       -
               }

     

       104
       -
             }));

     

       0
        
       
     

       0
        
       
     

       105
        
           };

     

       106
        
       

     

       107
        
           sinks.subscribe(fn)(source).unsubscribe();

     
···

       112
        
       describe('publish', () => {

     

       113
        
         it('sends Pull talkback signals every Push signal', () => {

     

       114
        
           let pulls = 0;

     

       115
       -
           const source: Source<any> = (sink) => {

     

       116
       -
             sink(start((signal) => {

     

       117
       -
               if (signal === TalkbackKind.Pull) {

     

       118
       -
                 if (pulls < 3) {

     

       119
       -
                   pulls++;

     

       120
       -
                   sink(push(0));

     

       121
       -
                 } else {

     

       122
       -
                   sink(SignalKind.End);

     

       123
       -
                   expect(pulls).toBe(3);

     

       0
        
       
     

       0
        
       
     

       124
        
                 }

     

       125
       -
               }

     

       126
       -
             }));

     

       127
        
           };

     

       128
        
       

     

       129
        
           sinks.publish(source);

     
···

       134
        
       describe('toArray', () => {

     

       135
        
         it('sends Pull talkback signals every Push signal', () => {

     

       136
        
           let pulls = 0;

     

       137
       -
           const source: Source<any> = (sink) => {

     

       138
       -
             sink(start((signal) => {

     

       139
       -
               if (signal === TalkbackKind.Pull) {

     

       140
       -
                 if (pulls < 3) {

     

       141
       -
                   pulls++;

     

       142
       -
                   sink(push(0));

     

       143
       -
                 } else {

     

       144
       -
                   sink(SignalKind.End);

     

       145
       -
                   expect(pulls).toBe(3);

     

       0
        
       
     

       0
        
       
     

       146
        
                 }

     

       147
       -
               }

     

       148
       -
             }));

     

       149
        
           };

     

       150
        
       

     

       151
        
           const array = sinks.toArray(source);

     
···

       157
        
           let pulls = 0;

     

       158
        
           let ending = 0;

     

       159
        
       

     

       160
       -
           const source: Source<any> = (sink) => {

     

       161
       -
             sink(start((signal) => {

     

       162
       -
               if (signal === TalkbackKind.Pull) {

     

       163
       -
                 if (!pulls) {

     

       164
       -
                   pulls++;

     

       165
       -
                   sink(push(0));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       166
        
                 }

     

       167
       -
               } else {

     

       168
       -
                 ending++;

     

       169
       -
               }

     

       170
       -
             }));

     

       171
        
           };

     

       172
        
       

     

       173
        
           const array = sinks.toArray(source);

     
···

       181
        
           let pulls = 0;

     

       182
        
           let sink: Sink<any> | null = null;

     

       183
        
       

     

       184
       -
           const source: Source<any> = (_sink) => {

     

       185
        
             sink = _sink;

     

       186
       -
             sink(start((signal) => {

     

       187
       -
               if (signal === TalkbackKind.Pull)

     

       188
       -
                 pulls++;

     

       189
       -
             }));

     

       0
        
       
     

       190
        
           };

     

       191
        
       

     

       192
        
           const fn = jest.fn();

     
···

       219
        
       

     

       220
        
           const source: Source<any> = _sink => {

     

       221
        
             sink = _sink;

     

       222
       -
             sink(start((signal) => {

     

       223
       -
               if (signal === TalkbackKind.Pull)

     

       224
       -
                 pulls++;

     

       225
       -
             }));

     

       0
        
       
     

       226
        
           };

     

       227
        
       

     

       228
        
           Observable.from(observable.toObservable(source) as any).subscribe({

     
···

       242
        
         it('forwards cancellations from the Observable as a talkback', () => {

     

       243
        
           let ending = 0;

     

       244
        
           const source: Source<T> = sink =>

     

       245
       -
             sink(start((signal) => {

     

       246
       -
               if (signal === TalkbackKind.Close)

     

       247
       -
                 ending++;

     

       248
       -
             }));

     

       0
        
       
     

       249
        
       

     

       250
        
           const sub = Observable.from(observable.toObservable(source) as any).subscribe({});

     

       251
        
       

     
···

       263
        
       

     

       264
        
           const source: Source<any> = _sink => {

     

       265
        
             sink = _sink;

     

       266
       -
             sink(start((signal) => {

     

       267
       -
               if (signal === TalkbackKind.Pull)

     

       268
       -
                 pulls++;

     

       269
       -
             }));

     

       0
        
       
     

       270
        
           };

     

       271
        
       

     

       272
        
           callbagIterate(fn)(callbag.toCallbag(source));

     
···

       284
        
           const fn = jest.fn();

     

       285
        
       

     

       286
        
           const source: Source<any> = sink =>

     

       287
       -
             sink(start((signal) => {

     

       288
       -
               if (signal === TalkbackKind.Pull) {

     

       289
       -
                 sink(push(0));

     

       290
       -
               } else {

     

       291
       -
                 ending++;

     

       292
       -
               }

     

       293
       -
             }));

     

       0
        
       
     

       0
        
       
     

       294
        
       

     

       295
        
           callbagIterate(fn)(callbagTake(1)(callbag.toCallbag(source) as any));

     

       296

···

       15
        
           let pulls = 0;

     

       16
        
           const fn = jest.fn();

     

       17
        
       

     

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

     

       19
       +
             sink(

     

       20
       +
               start(signal => {

     

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

     

       22
       +
                   if (pulls < 3) {

     

       23
       +
                     pulls++;

     

       24
       +
                     sink(push(0));

     

       25
       +
                   } else {

     

       26
       +
                     sink(SignalKind.End);

     

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

     

       28
       +
                   }

     

       29
        
                 }

     

       30
       +
               })

     

       31
       +
             );

     

       32
        
           };

     

       33
        
       

     

       34
        
           sinks.subscribe(fn)(source);

     
···

       40
        
           let pulls = 0;

     

       41
        
           let closing = 0;

     

       42
        
       

     

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

     

       44
       +
             sink(

     

       45
       +
               start(signal => {

     

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

     

       47
       +
                   if (!pulls) {

     

       48
       +
                     pulls++;

     

       49
       +
                     sink(push(0));

     

       50
       +
                   }

     

       51
       +
                 } else {

     

       52
       +
                   closing++;

     

       53
        
                 }

     

       54
       +
               })

     

       55
       +
             );

     

       0
        
       
     

       0
        
       
     

       56
        
           };

     

       57
        
       

     

       58
        
           const sub = sinks.subscribe(() => {})(source);

     
···

       66
        
           let pulls = 0;

     

       67
        
           let closing = 0;

     

       68
        
       

     

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

     

       70
       +
             sink(

     

       71
       +
               start(signal => {

     

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

     

       73
       +
                   pulls++;

     

       74
       +
                   sink(SignalKind.End);

     

       75
       +
                 } else {

     

       76
       +
                   closing++;

     

       77
       +
                 }

     

       78
       +
               })

     

       79
       +
             );

     

       80
        
           };

     

       81
        
       

     

       82
        
           const sub = sinks.subscribe(() => {})(source);

     
···

       87
        
       

     

       88
        
         it('ignores Push signals after the source has ended', () => {

     

       89
        
           const fn = jest.fn();

     

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

     

       91
       +
             sink(

     

       92
       +
               start(signal => {

     

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

     

       94
       +
                   sink(SignalKind.End);

     

       95
       +
                   sink(push(0));

     

       96
       +
                 }

     

       97
       +
               })

     

       98
       +
             );

     

       99
        
           };

     

       100
        
       

     

       101
        
           sinks.subscribe(fn)(source);

     
···

       104
        
       

     

       105
        
         it('ignores Push signals after cancellation', () => {

     

       106
        
           const fn = jest.fn();

     

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

     

       108
       +
             sink(

     

       109
       +
               start(signal => {

     

       110
       +
                 if (signal === TalkbackKind.Close) {

     

       111
       +
                   sink(push(0));

     

       112
       +
                 }

     

       113
       +
               })

     

       114
       +
             );

     

       115
        
           };

     

       116
        
       

     

       117
        
           sinks.subscribe(fn)(source).unsubscribe();

     
···

       122
        
       describe('publish', () => {

     

       123
        
         it('sends Pull talkback signals every Push signal', () => {

     

       124
        
           let pulls = 0;

     

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

     

       126
       +
             sink(

     

       127
       +
               start(signal => {

     

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

     

       129
       +
                   if (pulls < 3) {

     

       130
       +
                     pulls++;

     

       131
       +
                     sink(push(0));

     

       132
       +
                   } else {

     

       133
       +
                     sink(SignalKind.End);

     

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

     

       135
       +
                   }

     

       136
        
                 }

     

       137
       +
               })

     

       138
       +
             );

     

       139
        
           };

     

       140
        
       

     

       141
        
           sinks.publish(source);

     
···

       146
        
       describe('toArray', () => {

     

       147
        
         it('sends Pull talkback signals every Push signal', () => {

     

       148
        
           let pulls = 0;

     

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

     

       150
       +
             sink(

     

       151
       +
               start(signal => {

     

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

     

       153
       +
                   if (pulls < 3) {

     

       154
       +
                     pulls++;

     

       155
       +
                     sink(push(0));

     

       156
       +
                   } else {

     

       157
       +
                     sink(SignalKind.End);

     

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

     

       159
       +
                   }

     

       160
        
                 }

     

       161
       +
               })

     

       162
       +
             );

     

       163
        
           };

     

       164
        
       

     

       165
        
           const array = sinks.toArray(source);

     
···

       171
        
           let pulls = 0;

     

       172
        
           let ending = 0;

     

       173
        
       

     

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

     

       175
       +
             sink(

     

       176
       +
               start(signal => {

     

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

     

       178
       +
                   if (!pulls) {

     

       179
       +
                     pulls++;

     

       180
       +
                     sink(push(0));

     

       181
       +
                   }

     

       182
       +
                 } else {

     

       183
       +
                   ending++;

     

       184
        
                 }

     

       185
       +
               })

     

       186
       +
             );

     

       0
        
       
     

       0
        
       
     

       187
        
           };

     

       188
        
       

     

       189
        
           const array = sinks.toArray(source);

     
···

       197
        
           let pulls = 0;

     

       198
        
           let sink: Sink<any> | null = null;

     

       199
        
       

     

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

     

       201
        
             sink = _sink;

     

       202
       +
             sink(

     

       203
       +
               start(signal => {

     

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

     

       205
       +
               })

     

       206
       +
             );

     

       207
        
           };

     

       208
        
       

     

       209
        
           const fn = jest.fn();

     
···

       236
        
       

     

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

     

       238
        
             sink = _sink;

     

       239
       +
             sink(

     

       240
       +
               start(signal => {

     

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

     

       242
       +
               })

     

       243
       +
             );

     

       244
        
           };

     

       245
        
       

     

       246
        
           Observable.from(observable.toObservable(source) as any).subscribe({

     
···

       260
        
         it('forwards cancellations from the Observable as a talkback', () => {

     

       261
        
           let ending = 0;

     

       262
        
           const source: Source<T> = sink =>

     

       263
       +
             sink(

     

       264
       +
               start(signal => {

     

       265
       +
                 if (signal === TalkbackKind.Close) ending++;

     

       266
       +
               })

     

       267
       +
             );

     

       268
        
       

     

       269
        
           const sub = Observable.from(observable.toObservable(source) as any).subscribe({});

     

       270
        
       

     
···

       282
        
       

     

       283
        
           const source: Source<any> = _sink => {

     

       284
        
             sink = _sink;

     

       285
       +
             sink(

     

       286
       +
               start(signal => {

     

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

     

       288
       +
               })

     

       289
       +
             );

     

       290
        
           };

     

       291
        
       

     

       292
        
           callbagIterate(fn)(callbag.toCallbag(source));

     
···

       304
        
           const fn = jest.fn();

     

       305
        
       

     

       306
        
           const source: Source<any> = sink =>

     

       307
       +
             sink(

     

       308
       +
               start(signal => {

     

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

     

       310
       +
                   sink(push(0));

     

       311
       +
                 } else {

     

       312
       +
                   ending++;

     

       313
       +
                 }

     

       314
       +
               })

     

       315
       +
             );

     

       316
        
       

     

       317
        
           callbagIterate(fn)(callbagTake(1)(callbag.toCallbag(source) as any));

     

       318

+25 -98

src/__tests__/sources.test.ts

···

       9
        
       import callbagFromArray from 'callbag-from-iter';

     

       10
        
       import Observable from 'zen-observable';

     

       11
        
       

     

       12
       -
       const collectSignals = (

     

       13
       -
         source: Source<any>,

     

       14
       -
         onStart?: (talkbackCb: TalkbackFn) => void

     

       15
       -
       ) => {

     

       16
        
         let talkback = talkbackPlaceholder;

     

       17
        
         const signals: Signal<any>[] = [];

     

       18
        
         source(signal => {

     
···

       26
        
           } else {

     

       27
        
             talkback(TalkbackKind.Pull);

     

       28
        
           }

     

       29
       -
         })

     

       30
        
       

     

       31
        
         return signals;

     

       32
        
       };

     
···

       103
        
           };

     

       104
        
       

     

       105
        
           source(sink);

     

       106
       -
           expect(signals).toEqual([

     

       107
       -
             push(1),

     

       108
       -
             push(2),

     

       109
       -
             SignalKind.End,

     

       110
       -
           ]);

     

       111
        
         });

     

       112
        
       };

     

       113
        
       

     
···

       135
        
       });

     

       136
        
       

     

       137
        
       describe('merge', () => {

     

       138
       -
         const source = operators.merge<any>([

     

       139
       -
           sources.fromValue(0),

     

       140
       -
           sources.empty

     

       141
       -
         ]);

     

       142
        
       

     

       143
        
         passesColdPull(source);

     

       144
        
         passesActiveClose(source);

     

       145
        
       

     

       146
        
         it('correctly merges two sources where the second is empty', () => {

     

       147
       -
           const source = operators.merge<any>([

     

       148
       -
             sources.fromValue(0),

     

       149
       -
             sources.empty

     

       150
       -
           ]);

     

       151
        
       

     

       152
       -
           expect(collectSignals(source)).toEqual([

     

       153
       -
             start(expect.any(Function)),

     

       154
       -
             push(0),

     

       155
       -
             SignalKind.End,

     

       156
       -
           ]);

     

       157
        
         });

     

       158
        
       

     

       159
        
         it('correctly merges hot sources', () => {

     
···

       166
        
           const signals = collectSignals(source);

     

       167
        
           expect(onStart).toHaveBeenCalledTimes(2);

     

       168
        
       

     

       169
       -
           expect(signals).toEqual([

     

       170
       -
             start(expect.any(Function)),

     

       171
       -
             push(1),

     

       172
       -
             push(2),

     

       173
       -
           ]);

     

       174
        
         });

     

       175
        
       

     

       176
        
         it('correctly merges asynchronous sources', () => {

     
···

       179
        
           const onStart = jest.fn();

     

       180
        
           const source = operators.merge<any>([

     

       181
        
             operators.onStart(onStart)(sources.fromValue(-1)),

     

       182
       -
             operators.onStart(onStart)(

     

       183
       -
               operators.take(2)(sources.interval(50))

     

       184
       -
             ),

     

       185
        
           ]);

     

       186
        
       

     

       187
        
           const signals = collectSignals(source);

     
···

       199
        
       });

     

       200
        
       

     

       201
        
       describe('concat', () => {

     

       202
       -
         const source = operators.concat<any>([

     

       203
       -
           sources.fromValue(0),

     

       204
       -
           sources.empty

     

       205
       -
         ]);

     

       206
        
       

     

       207
        
         passesColdPull(source);

     

       208
        
         passesActiveClose(source);

     

       209
        
       

     

       210
        
         it('correctly concats two sources where the second is empty', () => {

     

       211
       -
           const source = operators.concat<any>([

     

       212
       -
             sources.fromValue(0),

     

       213
       -
             sources.empty

     

       214
       -
           ]);

     

       215
        
       

     

       216
       -
           expect(collectSignals(source)).toEqual([

     

       217
       -
             start(expect.any(Function)),

     

       218
       -
             push(0),

     

       219
       -
             SignalKind.End,

     

       220
       -
           ]);

     

       221
        
         });

     

       222
        
       });

     

       223
        
       

     
···

       234
        
           expect(signals).toEqual([start(expect.any(Function))]);

     

       235
        
           jest.runAllTimers();

     

       236
        
       

     

       237
       -
           expect(signals).toEqual([

     

       238
       -
             start(expect.any(Function)),

     

       239
       -
             push(1),

     

       240
       -
             SignalKind.End,

     

       241
       -
           ]);

     

       242
        
         });

     

       243
        
       

     

       244
        
         it('supports active cancellation', () => {

     
···

       263
        
           const { source, next, complete } = sources.makeSubject();

     

       264
        
           const signals = collectSignals(source);

     

       265
        
       

     

       266
       -
           expect(signals).toEqual([

     

       267
       -
             start(expect.any(Function)),

     

       268
       -
           ]);

     

       269
        
       

     

       270
        
           next(1);

     

       271
        
       

     

       272
       -
           expect(signals).toEqual([

     

       273
       -
             start(expect.any(Function)),

     

       274
       -
             push(1),

     

       275
       -
           ]);

     

       276
        
       

     

       277
        
           complete();

     

       278
        
       

     

       279
       -
           expect(signals).toEqual([

     

       280
       -
             start(expect.any(Function)),

     

       281
       -
             push(1),

     

       282
       -
             SignalKind.End,

     

       283
       -
           ]);

     

       284
        
         });

     

       285
        
       

     

       286
        
         it('ignores signals after complete has been called', () => {

     
···

       288
        
           const signals = collectSignals(source);

     

       289
        
           complete();

     

       290
        
       

     

       291
       -
           expect(signals).toEqual([

     

       292
       -
             start(expect.any(Function)),

     

       293
       -
             SignalKind.End,

     

       294
       -
           ]);

     

       295
        
       

     

       296
        
           next(1);

     

       297
        
           complete();

     
···

       302
        
       describe('never', () => {

     

       303
        
         it('emits nothing and ends immediately', () => {

     

       304
        
           const signals = collectSignals(sources.never);

     

       305
       -
           expect(signals).toEqual([start(expect.any(Function)) ]);

     

       306
        
         });

     

       307
        
       });

     

       308
        
       

     
···

       310
        
         it('emits nothing and ends immediately', () => {

     

       311
        
           const signals = collectSignals(sources.empty);

     

       312
        
       

     

       313
       -
           expect(signals).toEqual([

     

       314
       -
             start(expect.any(Function)),

     

       315
       -
             SignalKind.End,

     

       316
       -
           ]);

     

       317
        
         });

     

       318
        
       });

     

       319
        
       

     
···

       324
        
           const promise = Promise.resolve(1);

     

       325
        
           const signals = collectSignals(sources.fromPromise(promise));

     

       326
        
       

     

       327
       -
           expect(signals).toEqual([

     

       328
       -
             start(expect.any(Function)),

     

       329
       -
           ]);

     

       330
        
       

     

       331
        
           await promise;

     

       332
        
       

     

       333
       -
           expect(signals).toEqual([

     

       334
       -
             start(expect.any(Function)),

     

       335
       -
             push(1),

     

       336
       -
             SignalKind.End,

     

       337
       -
           ]);

     

       338
        
         });

     

       339
        
       });

     

       340
        
       

     
···

       349
        
       

     

       350
        
           await new Promise(resolve => setTimeout(resolve));

     

       351
        
       

     

       352
       -
           expect(signals).toEqual([

     

       353
       -
             start(expect.any(Function)),

     

       354
       -
             push(1),

     

       355
       -
             push(2),

     

       356
       -
             SignalKind.End,

     

       357
       -
           ]);

     

       358
        
         });

     

       359
        
       

     

       360
        
         it('supports cancellation on converted Observables', async () => {

     
···

       365
        
       

     

       366
        
           await new Promise(resolve => setTimeout(resolve));

     

       367
        
       

     

       368
       -
           expect(signals).toEqual([

     

       369
       -
             start(expect.any(Function)),

     

       370
       -
           ]);

     

       371
        
         });

     

       372
        
       });

     

       373
        
       

     
···

       376
        
           const source = callbag.fromCallbag(callbagFromArray([1, 2]) as any);

     

       377
        
           const signals = collectSignals(source);

     

       378
        
       

     

       379
       -
           expect(signals).toEqual([

     

       380
       -
             start(expect.any(Function)),

     

       381
       -
             push(1),

     

       382
       -
             push(2),

     

       383
       -
             SignalKind.End,

     

       384
       -
           ]);

     

       385
        
         });

     

       386
        
       

     

       387
        
         it('supports cancellation on converted Observables', () => {

     
···

       390
        
             talkback(TalkbackKind.Close);

     

       391
        
           });

     

       392
        
       

     

       393
       -
           expect(signals).toEqual([

     

       394
       -
             start(expect.any(Function)),

     

       395
       -
           ]);

     

       396
        
         });

     

       397
        
       });

     

       398
        
       

     
···

       437
        
       

     

       438
        
           const sink: Sink<any> = signal => {

     

       439
        
             expect(signal).not.toBe(SignalKind.End);

     

       440
       -
             if ((signal as any).tag === SignalKind.Start)

     

       441
       -
               talkback = signal[0];

     

       442
        
           };

     

       443
        
       

     

       444
        
           sources.fromDomEvent(element as any, 'click')(sink);

···

       9
        
       import callbagFromArray from 'callbag-from-iter';

     

       10
        
       import Observable from 'zen-observable';

     

       11
        
       

     

       12
       +
       const collectSignals = (source: Source<any>, onStart?: (talkbackCb: TalkbackFn) => void) => {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
         let talkback = talkbackPlaceholder;

     

       14
        
         const signals: Signal<any>[] = [];

     

       15
        
         source(signal => {

     
···

       23
        
           } else {

     

       24
        
             talkback(TalkbackKind.Pull);

     

       25
        
           }

     

       26
       +
         });

     

       27
        
       

     

       28
        
         return signals;

     

       29
        
       };

     
···

       100
        
           };

     

       101
        
       

     

       102
        
           source(sink);

     

       103
       +
           expect(signals).toEqual([push(1), push(2), SignalKind.End]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       104
        
         });

     

       105
        
       };

     

       106
        
       

     
···

       128
        
       });

     

       129
        
       

     

       130
        
       describe('merge', () => {

     

       131
       +
         const source = operators.merge<any>([sources.fromValue(0), sources.empty]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       132
        
       

     

       133
        
         passesColdPull(source);

     

       134
        
         passesActiveClose(source);

     

       135
        
       

     

       136
        
         it('correctly merges two sources where the second is empty', () => {

     

       137
       +
           const source = operators.merge<any>([sources.fromValue(0), sources.empty]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       138
        
       

     

       139
       +
           expect(collectSignals(source)).toEqual([start(expect.any(Function)), push(0), SignalKind.End]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       140
        
         });

     

       141
        
       

     

       142
        
         it('correctly merges hot sources', () => {

     
···

       149
        
           const signals = collectSignals(source);

     

       150
        
           expect(onStart).toHaveBeenCalledTimes(2);

     

       151
        
       

     

       152
       +
           expect(signals).toEqual([start(expect.any(Function)), push(1), push(2)]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       153
        
         });

     

       154
        
       

     

       155
        
         it('correctly merges asynchronous sources', () => {

     
···

       158
        
           const onStart = jest.fn();

     

       159
        
           const source = operators.merge<any>([

     

       160
        
             operators.onStart(onStart)(sources.fromValue(-1)),

     

       161
       +
             operators.onStart(onStart)(operators.take(2)(sources.interval(50))),

     

       0
        
       
     

       0
        
       
     

       162
        
           ]);

     

       163
        
       

     

       164
        
           const signals = collectSignals(source);

     
···

       176
        
       });

     

       177
        
       

     

       178
        
       describe('concat', () => {

     

       179
       +
         const source = operators.concat<any>([sources.fromValue(0), sources.empty]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       180
        
       

     

       181
        
         passesColdPull(source);

     

       182
        
         passesActiveClose(source);

     

       183
        
       

     

       184
        
         it('correctly concats two sources where the second is empty', () => {

     

       185
       +
           const source = operators.concat<any>([sources.fromValue(0), sources.empty]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       186
        
       

     

       187
       +
           expect(collectSignals(source)).toEqual([start(expect.any(Function)), push(0), SignalKind.End]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       188
        
         });

     

       189
        
       });

     

       190
        
       

     
···

       201
        
           expect(signals).toEqual([start(expect.any(Function))]);

     

       202
        
           jest.runAllTimers();

     

       203
        
       

     

       204
       +
           expect(signals).toEqual([start(expect.any(Function)), push(1), SignalKind.End]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       205
        
         });

     

       206
        
       

     

       207
        
         it('supports active cancellation', () => {

     
···

       226
        
           const { source, next, complete } = sources.makeSubject();

     

       227
        
           const signals = collectSignals(source);

     

       228
        
       

     

       229
       +
           expect(signals).toEqual([start(expect.any(Function))]);

     

       0
        
       
     

       0
        
       
     

       230
        
       

     

       231
        
           next(1);

     

       232
        
       

     

       233
       +
           expect(signals).toEqual([start(expect.any(Function)), push(1)]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       234
        
       

     

       235
        
           complete();

     

       236
        
       

     

       237
       +
           expect(signals).toEqual([start(expect.any(Function)), push(1), SignalKind.End]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       238
        
         });

     

       239
        
       

     

       240
        
         it('ignores signals after complete has been called', () => {

     
···

       242
        
           const signals = collectSignals(source);

     

       243
        
           complete();

     

       244
        
       

     

       245
       +
           expect(signals).toEqual([start(expect.any(Function)), SignalKind.End]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       246
        
       

     

       247
        
           next(1);

     

       248
        
           complete();

     
···

       253
        
       describe('never', () => {

     

       254
        
         it('emits nothing and ends immediately', () => {

     

       255
        
           const signals = collectSignals(sources.never);

     

       256
       +
           expect(signals).toEqual([start(expect.any(Function))]);

     

       257
        
         });

     

       258
        
       });

     

       259
        
       

     
···

       261
        
         it('emits nothing and ends immediately', () => {

     

       262
        
           const signals = collectSignals(sources.empty);

     

       263
        
       

     

       264
       +
           expect(signals).toEqual([start(expect.any(Function)), SignalKind.End]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       265
        
         });

     

       266
        
       });

     

       267
        
       

     
···

       272
        
           const promise = Promise.resolve(1);

     

       273
        
           const signals = collectSignals(sources.fromPromise(promise));

     

       274
        
       

     

       275
       +
           expect(signals).toEqual([start(expect.any(Function))]);

     

       0
        
       
     

       0
        
       
     

       276
        
       

     

       277
        
           await promise;

     

       278
        
       

     

       279
       +
           expect(signals).toEqual([start(expect.any(Function)), push(1), SignalKind.End]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       280
        
         });

     

       281
        
       });

     

       282
        
       

     
···

       291
        
       

     

       292
        
           await new Promise(resolve => setTimeout(resolve));

     

       293
        
       

     

       294
       +
           expect(signals).toEqual([start(expect.any(Function)), push(1), push(2), SignalKind.End]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       295
        
         });

     

       296
        
       

     

       297
        
         it('supports cancellation on converted Observables', async () => {

     
···

       302
        
       

     

       303
        
           await new Promise(resolve => setTimeout(resolve));

     

       304
        
       

     

       305
       +
           expect(signals).toEqual([start(expect.any(Function))]);

     

       0
        
       
     

       0
        
       
     

       306
        
         });

     

       307
        
       });

     

       308
        
       

     
···

       311
        
           const source = callbag.fromCallbag(callbagFromArray([1, 2]) as any);

     

       312
        
           const signals = collectSignals(source);

     

       313
        
       

     

       314
       +
           expect(signals).toEqual([start(expect.any(Function)), push(1), push(2), SignalKind.End]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       315
        
         });

     

       316
        
       

     

       317
        
         it('supports cancellation on converted Observables', () => {

     
···

       320
        
             talkback(TalkbackKind.Close);

     

       321
        
           });

     

       322
        
       

     

       323
       +
           expect(signals).toEqual([start(expect.any(Function))]);

     

       0
        
       
     

       0
        
       
     

       324
        
         });

     

       325
        
       });

     

       326
        
       

     
···

       365
        
       

     

       366
        
           const sink: Sink<any> = signal => {

     

       367
        
             expect(signal).not.toBe(SignalKind.End);

     

       368
       +
             if ((signal as any).tag === SignalKind.Start) talkback = signal[0];

     

       0
        
       
     

       369
        
           };

     

       370
        
       

     

       371
        
           sources.fromDomEvent(element as any, 'click')(sink);

+13 -11

src/callbag.ts

···

       1
       -
       import { Source, SignalKind, TalkbackKind } from './types'

     

       2
       -
       import { push, start } from './helpers'

     

       3
        
       

     

       4
        
       interface Callbag<I, O> {

     

       5
        
         (t: 0, d: Callbag<O, I>): void;

     
···

       8
        
       }

     

       9
        
       

     

       10
        
       export function fromCallbag<T>(callbag: Callbag<any, T>): Source<T> {

     

       11
       -
         return (sink) => {

     

       12
        
           callbag(0, (signal: number, data: any) => {

     

       13
        
             if (signal === 0) {

     

       14
       -
               sink(start((signal) => {

     

       15
       -
                 if (signal === TalkbackKind.Pull) {

     

       16
       -
                   data(1);

     

       17
       -
                 } else {

     

       18
       -
                   data(2);

     

       19
       -
                 }

     

       20
       -
               }));

     

       0
        
       
     

       0
        
       
     

       21
        
             } else if (signal === 1) {

     

       22
        
               sink(push(data));

     

       23
        
             } else if (signal === 2) {

     
···

       30
        
       export function toCallbag<T>(source: Source<T>): Callbag<any, T> {

     

       31
        
         return (signal: number, sink: any) => {

     

       32
        
           if (signal === 0) {

     

       33
       -
             source((signal) => {

     

       34
        
               if (signal === SignalKind.End) {

     

       35
        
                 sink(2);

     

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

···

       1
       +
       import { Source, SignalKind, TalkbackKind } from './types';

     

       2
       +
       import { push, start } from './helpers';

     

       3
        
       

     

       4
        
       interface Callbag<I, O> {

     

       5
        
         (t: 0, d: Callbag<O, I>): void;

     
···

       8
        
       }

     

       9
        
       

     

       10
        
       export function fromCallbag<T>(callbag: Callbag<any, T>): Source<T> {

     

       11
       +
         return sink => {

     

       12
        
           callbag(0, (signal: number, data: any) => {

     

       13
        
             if (signal === 0) {

     

       14
       +
               sink(

     

       15
       +
                 start(signal => {

     

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

     

       17
       +
                     data(1);

     

       18
       +
                   } else {

     

       19
       +
                     data(2);

     

       20
       +
                   }

     

       21
       +
                 })

     

       22
       +
               );

     

       23
        
             } else if (signal === 1) {

     

       24
        
               sink(push(data));

     

       25
        
             } else if (signal === 2) {

     
···

       32
        
       export function toCallbag<T>(source: Source<T>): Callbag<any, T> {

     

       33
        
         return (signal: number, sink: any) => {

     

       34
        
           if (signal === 0) {

     

       35
       +
             source(signal => {

     

       36
        
               if (signal === SignalKind.End) {

     

       37
        
                 sink(2);

     

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

+9 -5

src/helpers.ts

···

       1
       -
       import { TalkbackFn, TeardownFn, Start, Push, SignalKind } from './types'

     

       2
        
       

     

       3
       -
       export const talkbackPlaceholder: TalkbackFn = (_signal) => {/*noop*/};

     

       4
       -
       export const teardownPlaceholder: TeardownFn = () => {/*noop*/};

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5
        
       

     

       6
        
       export function start<T>(talkback: TalkbackFn): Start<T> {

     

       7
        
         const box: any = [talkback];

     

       8
        
         box.tag = SignalKind.Start;

     

       9
       -
         return box

     

       10
        
       }

     

       11
        
       

     

       12
        
       export function push<T>(value: T): Push<T> {

     

       13
        
         const box: any = [value];

     

       14
        
         box.tag = SignalKind.Push;

     

       15
       -
         return box

     

       16
        
       }

···

       1
       +
       import { TalkbackFn, TeardownFn, Start, Push, SignalKind } from './types';

     

       2
        
       

     

       3
       +
       export const talkbackPlaceholder: TalkbackFn = _signal => {

     

       4
       +
         /*noop*/

     

       5
       +
       };

     

       6
       +
       export const teardownPlaceholder: TeardownFn = () => {

     

       7
       +
         /*noop*/

     

       8
       +
       };

     

       9
        
       

     

       10
        
       export function start<T>(talkback: TalkbackFn): Start<T> {

     

       11
        
         const box: any = [talkback];

     

       12
        
         box.tag = SignalKind.Start;

     

       13
       +
         return box;

     

       14
        
       }

     

       15
        
       

     

       16
        
       export function push<T>(value: T): Push<T> {

     

       17
        
         const box: any = [value];

     

       18
        
         box.tag = SignalKind.Push;

     

       19
       +
         return box;

     

       20
        
       }

+7 -7

src/index.ts

···

       1
       -
       export * from './types'

     

       2
       -
       export * from './sources'

     

       3
       -
       export * from './operators'

     

       4
       -
       export * from './sinks'

     

       5
       -
       export * from './observable'

     

       6
       -
       export * from './callbag'

     

       7
       -
       export * from './pipe'

···

       1
       +
       export * from './types';

     

       2
       +
       export * from './sources';

     

       3
       +
       export * from './operators';

     

       4
       +
       export * from './sinks';

     

       5
       +
       export * from './observable';

     

       6
       +
       export * from './callbag';

     

       7
       +
       export * from './pipe';

+16 -11

src/observable.ts

···

       1
       -
       import { Source, SignalKind, TalkbackKind } from './types'

     

       2
       -
       import { push, start, talkbackPlaceholder } from './helpers'

     

       3
        
       

     

       4
        
       interface ObservableSubscription {

     

       5
        
         closed?: boolean;

     
···

       16
        
         subscribe(observer: ObservableObserver<T>): ObservableSubscription;

     

       17
        
       }

     

       18
        
       

     

       19
       -
       const observableSymbol: unique symbol = typeof Symbol === 'function'

     

       20
       -
         ? (Symbol as any).observable || ((Symbol as any).observable = Symbol('observable'))

     

       21
       -
         : '@@observable'

     

       0
        
       
     

       22
        
       

     

       23
        
       export function fromObservable<T>(input: Observable<T>): Source<T> {

     

       24
        
         const observable: Observable<T> = input[observableSymbol]

     

       25
        
           ? (input as any)[observableSymbol]()

     

       26
        
           : input;

     

       27
       -
         return (sink) => {

     

       28
        
           const subscription = observable.subscribe({

     

       29
        
             next(value: T) {

     

       30
        
               sink(push(value));

     
···

       32
        
             complete() {

     

       33
        
               sink(SignalKind.End);

     

       34
        
             },

     

       35
       -
             error() {/*noop*/},

     

       0
        
       
     

       0
        
       
     

       36
        
           });

     

       37
       -
           sink(start((signal) => {

     

       38
       -
             if (signal === TalkbackKind.Close) subscription.unsubscribe();

     

       39
       -
           }));

     

       0
        
       
     

       0
        
       
     

       40
        
         };

     

       41
        
       }

     

       42
        
       

     
···

       45
        
           subscribe(observer: ObservableObserver<T>) {

     

       46
        
             let talkback = talkbackPlaceholder;

     

       47
        
             let ended = false;

     

       48
       -
             source((signal) => {

     

       49
        
               if (ended) {

     

       50
        
                 /*noop*/

     

       51
        
               } else if (signal === SignalKind.End) {

···

       1
       +
       import { Source, SignalKind, TalkbackKind } from './types';

     

       2
       +
       import { push, start, talkbackPlaceholder } from './helpers';

     

       3
        
       

     

       4
        
       interface ObservableSubscription {

     

       5
        
         closed?: boolean;

     
···

       16
        
         subscribe(observer: ObservableObserver<T>): ObservableSubscription;

     

       17
        
       }

     

       18
        
       

     

       19
       +
       const observableSymbol: unique symbol =

     

       20
       +
         typeof Symbol === 'function'

     

       21
       +
           ? (Symbol as any).observable || ((Symbol as any).observable = Symbol('observable'))

     

       22
       +
           : '@@observable';

     

       23
        
       

     

       24
        
       export function fromObservable<T>(input: Observable<T>): Source<T> {

     

       25
        
         const observable: Observable<T> = input[observableSymbol]

     

       26
        
           ? (input as any)[observableSymbol]()

     

       27
        
           : input;

     

       28
       +
         return sink => {

     

       29
        
           const subscription = observable.subscribe({

     

       30
        
             next(value: T) {

     

       31
        
               sink(push(value));

     
···

       33
        
             complete() {

     

       34
        
               sink(SignalKind.End);

     

       35
        
             },

     

       36
       +
             error() {

     

       37
       +
               /*noop*/

     

       38
       +
             },

     

       39
        
           });

     

       40
       +
           sink(

     

       41
       +
             start(signal => {

     

       42
       +
               if (signal === TalkbackKind.Close) subscription.unsubscribe();

     

       43
       +
             })

     

       44
       +
           );

     

       45
        
         };

     

       46
        
       }

     

       47
        
       

     
···

       50
        
           subscribe(observer: ObservableObserver<T>) {

     

       51
        
             let talkback = talkbackPlaceholder;

     

       52
        
             let ended = false;

     

       53
       +
             source(signal => {

     

       54
        
               if (ended) {

     

       55
        
                 /*noop*/

     

       56
        
               } else if (signal === SignalKind.End) {

+266 -244

src/operators.ts

···

       1
       -
       import { Source, Sink, Operator, SignalKind, TalkbackKind, TalkbackFn } from './types'

     

       2
       -
       import { push, start, talkbackPlaceholder } from './helpers'

     

       3
       -
       import { fromArray } from './sources'

     

       4
        
       

     

       5
        
       const identity = <T>(x: T): T => x;

     

       6
        
       

     

       7
        
       export function buffer<S, T>(notifier: Source<S>): Operator<T, T[]> {

     

       8
       -
         return (source) => (sink) => {

     

       9
        
           let buffer: T[] = [];

     

       10
        
           let sourceTalkback = talkbackPlaceholder;

     

       11
        
           let notifierTalkback = talkbackPlaceholder;

     

       12
        
           let pulled = false;

     

       13
        
           let ended = false;

     

       14
       -
           source((signal) => {

     

       15
        
             if (ended) {

     

       16
        
               /*noop*/

     

       17
        
             } else if (signal === SignalKind.End) {

     
···

       21
        
               sink(SignalKind.End);

     

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

     

       23
        
               sourceTalkback = signal[0];

     

       24
       -
               notifier((signal) => {

     

       25
        
                 if (ended) {

     

       26
        
                   /*noop*/

     

       27
        
                 } else if (signal === SignalKind.End) {

     
···

       48
        
               }

     

       49
        
             }

     

       50
        
           });

     

       51
       -
           sink(start((signal) => {

     

       52
       -
             if (signal === TalkbackKind.Close && !ended) {

     

       53
       -
               ended = true;

     

       54
       -
               sourceTalkback(TalkbackKind.Close);

     

       55
       -
               notifierTalkback(TalkbackKind.Close);

     

       56
       -
             } else if (!ended && !pulled) {

     

       57
       -
               pulled = true;

     

       58
       -
               sourceTalkback(TalkbackKind.Pull);

     

       59
       -
               notifierTalkback(TalkbackKind.Pull);

     

       60
       -
             }

     

       61
       -
           }));

     

       0
        
       
     

       0
        
       
     

       62
        
         };

     

       63
        
       }

     

       64
        
       

     

       65
        
       export function combine<A, B>(sourceA: Source<A>, sourceB: Source<B>): Source<[A, B]> {

     

       66
       -
         return (sink) => {

     

       67
        
           let lastValA: A | void;

     

       68
        
           let lastValB: B | void;

     

       69
        
           let talkbackA = talkbackPlaceholder;

     
···

       71
        
           let gotSignal = false;

     

       72
        
           let gotEnd = false;

     

       73
        
           let ended = false;

     

       74
       -
           sourceA((signal) => {

     

       75
        
             if (signal === SignalKind.End) {

     

       76
        
               if (!gotEnd) {

     

       77
        
                 gotEnd = true;

     
···

       94
        
               sink(push([lastValA, lastValB] as [A, B]));

     

       95
        
             }

     

       96
        
           });

     

       97
       -
           sourceB((signal) => {

     

       98
        
             if (signal === SignalKind.End) {

     

       99
        
               if (!gotEnd) {

     

       100
        
                 gotEnd = true;

     
···

       117
        
               sink(push([lastValA, lastValB] as [A, B]));

     

       118
        
             }

     

       119
        
           });

     

       120
       -
           sink(start((signal) => {

     

       121
       -
             if (ended) {

     

       122
       -
               /*noop*/

     

       123
       -
             } else if (signal === TalkbackKind.Close) {

     

       124
       -
               ended = true;

     

       125
       -
               talkbackA(TalkbackKind.Close);

     

       126
       -
               talkbackB(TalkbackKind.Close);

     

       127
       -
             } else if (!gotSignal) {

     

       128
       -
               gotSignal = true;

     

       129
       -
               talkbackA(TalkbackKind.Pull);

     

       130
       -
               talkbackB(TalkbackKind.Pull);

     

       131
       -
             }

     

       132
       -
           }));

     

       0
        
       
     

       0
        
       
     

       133
        
         };

     

       134
        
       }

     

       135
        
       

     

       136
        
       export function concatMap<In, Out>(map: (value: In) => Source<Out>): Operator<In, Out> {

     

       137
       -
         return (source) => (sink) => {

     

       138
        
           const inputQueue: In[] = [];

     

       139
        
           let outerTalkback = talkbackPlaceholder;

     

       140
        
           let innerTalkback = talkbackPlaceholder;

     
···

       144
        
           let ended = false;

     

       145
        
           function applyInnerSource(innerSource: Source<Out>): void {

     

       146
        
             innerActive = true;

     

       147
       -
             innerSource((signal) => {

     

       148
        
               if (signal === SignalKind.End) {

     

       149
        
                 if (innerActive) {

     

       150
        
                   innerActive = false;

     

       151
        
                   if (inputQueue.length) {

     

       152
       -
                     applyInnerSource(map(inputQueue.shift()!))

     

       153
        
                   } else if (ended) {

     

       154
        
                     sink(SignalKind.End);

     

       155
        
                   } else if (!outerPulled) {

     
···

       170
        
               }

     

       171
        
             });

     

       172
        
           }

     

       173
       -
           source((signal) => {

     

       174
        
             if (ended) {

     

       175
        
               /*noop*/

     

       176
        
             } else if (signal === SignalKind.End) {

     

       177
        
               ended = true;

     

       178
       -
               if (!innerActive && !inputQueue.length)

     

       179
       -
                 sink(SignalKind.End);

     

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

     

       181
        
               outerTalkback = signal[0];

     

       182
        
             } else {

     
···

       188
        
               }

     

       189
        
             }

     

       190
        
           });

     

       191
       -
           sink(start((signal) => {

     

       192
       -
             if (signal === TalkbackKind.Close) {

     

       193
       -
               if (!ended) {

     

       194
       -
                 ended = true;

     

       195
       -
                 outerTalkback(TalkbackKind.Close);

     

       196
       -
               }

     

       197
       -
               if (innerActive) {

     

       198
       -
                 innerActive = false;

     

       199
       -
                 innerTalkback(TalkbackKind.Close);

     

       200
       -
               }

     

       201
       -
             } else {

     

       202
       -
               if (!ended && !outerPulled) {

     

       203
       -
                 outerPulled = true;

     

       204
       -
                 outerTalkback(TalkbackKind.Pull);

     

       205
       -
               }

     

       206
       -
               if (innerActive && !innerPulled) {

     

       207
       -
                 innerPulled = true;

     

       208
       -
                 innerTalkback(TalkbackKind.Pull);

     

       0
        
       
     

       0
        
       
     

       209
        
               }

     

       210
       -
             }

     

       211
       -
           }));

     

       212
        
         };

     

       213
        
       }

     

       214
        
       

     
···

       221
        
       }

     

       222
        
       

     

       223
        
       export function filter<T>(predicate: (value: T) => boolean): Operator<T, T> {

     

       224
       -
         return (source) => (sink) => {

     

       225
        
           let talkback = talkbackPlaceholder;

     

       226
       -
           source((signal) => {

     

       227
        
             if (signal === SignalKind.End) {

     

       228
        
               sink(signal);

     

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

     
···

       239
        
       }

     

       240
        
       

     

       241
        
       export function map<In, Out>(map: (value: In) => Out): Operator<In, Out> {

     

       242
       -
         return (source) => (sink) => source((signal) => {

     

       243
       -
           if (signal === SignalKind.End || signal.tag === SignalKind.Start) {

     

       244
       -
             sink(signal);

     

       245
       -
           } else {

     

       246
       -
             sink(push(map(signal[0])));

     

       247
       -
           }

     

       248
       -
         });

     

       0
        
       
     

       249
        
       }

     

       250
        
       

     

       251
        
       export function mergeMap<In, Out>(map: (value: In) => Source<Out>): Operator<In, Out> {

     

       252
       -
         return (source) => (sink) => {

     

       253
        
           const innerTalkbacks: TalkbackFn[] = [];

     

       254
        
           let outerTalkback = talkbackPlaceholder;

     

       255
        
           let outerPulled = false;

     

       256
        
           let ended = false;

     

       257
        
           function applyInnerSource(innerSource: Source<Out>): void {

     

       258
        
             let talkback = talkbackPlaceholder;

     

       259
       -
             innerSource((signal) => {

     

       260
        
               if (signal === SignalKind.End) {

     

       261
        
                 if (innerTalkbacks.length) {

     

       262
        
                   const index = innerTalkbacks.indexOf(talkback);

     
···

       271
        
                   }

     

       272
        
                 }

     

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

     

       274
       -
                 innerTalkbacks.push(talkback = signal[0]);

     

       275
        
                 talkback(TalkbackKind.Pull);

     

       276
        
               } else if (innerTalkbacks.length) {

     

       277
        
                 sink(signal);

     
···

       279
        
               }

     

       280
        
             });

     

       281
        
           }

     

       282
       -
           source((signal) => {

     

       283
        
             if (ended) {

     

       284
        
               /*noop*/

     

       285
        
             } else if (signal === SignalKind.End) {

     

       286
        
               ended = true;

     

       287
       -
               if (!innerTalkbacks.length)

     

       288
       -
                 sink(SignalKind.End);

     

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

     

       290
        
               outerTalkback = signal[0];

     

       291
        
             } else {

     
···

       297
        
               }

     

       298
        
             }

     

       299
        
           });

     

       300
       -
           sink(start((signal) => {

     

       301
       -
             if (signal === TalkbackKind.Close) {

     

       302
       -
               if (!ended) {

     

       303
       -
                 ended = true;

     

       304
       -
                 outerTalkback(TalkbackKind.Close);

     

       305
       -
               }

     

       306
       -
               while (innerTalkbacks.length)

     

       307
       -
                 innerTalkbacks.pop()!(TalkbackKind.Close);

     

       308
       -
             } else {

     

       309
       -
               if (!ended && !outerPulled) {

     

       310
       -
                 outerPulled = true;

     

       311
       -
                 outerTalkback(TalkbackKind.Pull);

     

       312
        
               } else {

     

       313
       -
                 outerPulled = false;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       314
        
               }

     

       315
       -
               for (let i = 0; i < innerTalkbacks.length; i++)

     

       316
       -
                 innerTalkbacks[i](TalkbackKind.Pull);

     

       317
       -
             }

     

       318
       -
           }));

     

       319
        
         };

     

       320
        
       }

     

       321
        
       

     
···

       328
        
       }

     

       329
        
       

     

       330
        
       export function onEnd<T>(callback: () => void): Operator<T, T> {

     

       331
       -
         return (source) => (sink) => {

     

       332
        
           let ended = false;

     

       333
       -
           source((signal) => {

     

       334
        
             if (ended) {

     

       335
        
               /*noop*/

     

       336
        
             } else if (signal === SignalKind.End) {

     
···

       339
        
               callback();

     

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

     

       341
        
               const talkback = signal[0];

     

       342
       -
               sink(start((signal) => {

     

       343
       -
                 if (signal === TalkbackKind.Close) {

     

       344
       -
                   ended = true;

     

       345
       -
                   talkback(TalkbackKind.Close);

     

       346
       -
                   callback();

     

       347
       -
                 } else {

     

       348
       -
                   talkback(signal);

     

       349
       -
                 }

     

       350
       -
               }));

     

       0
        
       
     

       0
        
       
     

       351
        
             } else {

     

       352
        
               sink(signal);

     

       353
        
             }

     
···

       356
        
       }

     

       357
        
       

     

       358
        
       export function onPush<T>(callback: (value: T) => void): Operator<T, T> {

     

       359
       -
         return (source) => (sink) => {

     

       360
        
           let ended = false;

     

       361
       -
           source((signal) => {

     

       362
        
             if (ended) {

     

       363
        
               /*noop*/

     

       364
        
             } else if (signal === SignalKind.End) {

     
···

       366
        
               sink(SignalKind.End);

     

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

     

       368
        
               const talkback = signal[0];

     

       369
       -
               sink(start((signal) => {

     

       370
       -
                 if (signal === TalkbackKind.Close) ended = true;

     

       371
       -
                 talkback(signal);

     

       372
       -
               }));

     

       0
        
       
     

       0
        
       
     

       373
        
             } else {

     

       374
        
               callback(signal[0]);

     

       375
        
               sink(signal);

     
···

       379
        
       }

     

       380
        
       

     

       381
        
       export function onStart<T>(callback: () => void): Operator<T, T> {

     

       382
       -
         return (source) => (sink) => source((signal) => {

     

       383
       -
           if (signal === SignalKind.End) {

     

       384
       -
             sink(SignalKind.End);

     

       385
       -
           } else if (signal.tag === SignalKind.Start) {

     

       386
       -
             sink(signal);

     

       387
       -
             callback();

     

       388
       -
           } else {

     

       389
       -
             sink(signal);

     

       390
       -
           }

     

       391
       -
         });

     

       0
        
       
     

       392
        
       }

     

       393
        
       

     

       394
        
       export function sample<S, T>(notifier: Source<S>): Operator<T, T> {

     

       395
       -
         return (source) => (sink) => {

     

       396
        
           let sourceTalkback = talkbackPlaceholder;

     

       397
        
           let notifierTalkback = talkbackPlaceholder;

     

       398
        
           let value: T | void;

     

       399
        
           let pulled = false;

     

       400
        
           let ended = false;

     

       401
       -
           source((signal) => {

     

       402
        
             if (ended) {

     

       403
        
               /*noop*/

     

       404
        
             } else if (signal === SignalKind.End) {

     
···

       418
        
               }

     

       419
        
             }

     

       420
        
           });

     

       421
       -
           notifier((signal) => {

     

       422
        
             if (ended) {

     

       423
        
               /*noop*/

     

       424
        
             } else if (signal === SignalKind.End) {

     
···

       433
        
               sink(signal);

     

       434
        
             }

     

       435
        
           });

     

       436
       -
           sink(start((signal) => {

     

       437
       -
             if (signal === TalkbackKind.Close && !ended) {

     

       438
       -
               ended = true;

     

       439
       -
               sourceTalkback(TalkbackKind.Close);

     

       440
       -
               notifierTalkback(TalkbackKind.Close);

     

       441
       -
             } else if (!ended && !pulled) {

     

       442
       -
               pulled = true;

     

       443
       -
               sourceTalkback(TalkbackKind.Pull);

     

       444
       -
               notifierTalkback(TalkbackKind.Pull);

     

       445
       -
             }

     

       446
       -
           }));

     

       0
        
       
     

       0
        
       
     

       447
        
         };

     

       448
        
       }

     

       449
        
       

     

       450
        
       export function scan<In, Out>(reducer: (acc: Out, value: In) => Out, seed: Out): Operator<In, Out> {

     

       451
       -
         return (source) => (sink) => {

     

       452
        
           let acc = seed;

     

       453
       -
           source((signal) => {

     

       454
        
             if (signal === SignalKind.End) {

     

       455
        
               sink(SignalKind.End);

     

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

     

       457
        
               sink(signal);

     

       458
        
             } else {

     

       459
       -
               sink(push(acc = reducer(acc, signal[0])));

     

       460
        
             }

     

       461
        
           });

     

       462
        
         };

     
···

       466
        
         const sinks: Sink<T>[] = [];

     

       467
        
         let talkback = talkbackPlaceholder;

     

       468
        
         let gotSignal = false;

     

       469
       -
         return (sink) => {

     

       470
        
           sinks.push(sink);

     

       471
        
           if (sinks.length === 1) {

     

       472
       -
             source((signal) => {

     

       473
        
               if (signal === SignalKind.End) {

     

       474
        
                 while (sinks.length) sinks.pop()!(SignalKind.End);

     

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

     
···

       480
        
               }

     

       481
        
             });

     

       482
        
           }

     

       483
       -
           sink(start((signal) => {

     

       484
       -
             if (signal === TalkbackKind.Close) {

     

       485
       -
               const index = sinks.indexOf(sink);

     

       486
       -
               if (index > -1) sinks.splice(index, 1);

     

       487
       -
               if (!sinks.length) talkback(TalkbackKind.Close);

     

       488
       -
             } else if (signal === TalkbackKind.Pull && !gotSignal) {

     

       489
       -
               gotSignal = true;

     

       490
       -
               talkback(TalkbackKind.Pull);

     

       491
       -
             }

     

       492
       -
           }));

     

       0
        
       
     

       0
        
       
     

       493
        
         };

     

       494
        
       }

     

       495
        
       

     

       496
        
       export function skip<T>(wait: number): Operator<T, T> {

     

       497
       -
         return (source) => (sink) => {

     

       498
        
           let talkback = talkbackPlaceholder;

     

       499
        
           let rest = wait;

     

       500
       -
           source((signal) => {

     

       501
        
             if (signal === SignalKind.End) {

     

       502
        
               sink(SignalKind.End);

     

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

     
···

       513
        
       }

     

       514
        
       

     

       515
        
       export function skipUntil<S, T>(notifier: Source<S>): Operator<T, T> {

     

       516
       -
         return (source) => (sink) => {

     

       517
        
           let sourceTalkback = talkbackPlaceholder;

     

       518
        
           let notifierTalkback = talkbackPlaceholder;

     

       519
        
           let skip = true;

     

       520
        
           let pulled = false;

     

       521
        
           let ended = false;

     

       522
       -
           source((signal) => {

     

       523
        
             if (ended) {

     

       524
        
               /*noop*/

     

       525
        
             } else if (signal === SignalKind.End) {

     
···

       528
        
               sink(SignalKind.End);

     

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

     

       530
        
               sourceTalkback = signal[0];

     

       531
       -
               notifier((signal) => {

     

       532
        
                 if (signal === SignalKind.End) {

     

       533
        
                   if (skip) {

     

       534
        
                     ended = true;

     
···

       552
        
               pulled = false;

     

       553
        
             }

     

       554
        
           });

     

       555
       -
           sink(start((signal) => {

     

       556
       -
             if (signal === TalkbackKind.Close && !ended) {

     

       557
       -
               ended = true;

     

       558
       -
               sourceTalkback(TalkbackKind.Close);

     

       559
       -
               if (skip) notifierTalkback(TalkbackKind.Close);

     

       560
       -
             } else if (!ended && !pulled) {

     

       561
       -
               pulled = true;

     

       562
       -
               if (skip) notifierTalkback(TalkbackKind.Pull);

     

       563
       -
               sourceTalkback(TalkbackKind.Pull);

     

       564
       -
             }

     

       565
       -
           }));

     

       0
        
       
     

       0
        
       
     

       566
        
         };

     

       567
        
       }

     

       568
        
       

     

       569
        
       export function skipWhile<T>(predicate: (value: T) => boolean): Operator<T, T> {

     

       570
       -
         return (source) => (sink) => {

     

       571
        
           let talkback = talkbackPlaceholder;

     

       572
        
           let skip = true;

     

       573
       -
           source((signal) => {

     

       574
        
             if (signal === SignalKind.End) {

     

       575
        
               sink(SignalKind.End);

     

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

     
···

       591
        
       }

     

       592
        
       

     

       593
        
       export function switchMap<In, Out>(map: (value: In) => Source<Out>): Operator<In, Out> {

     

       594
       -
         return (source) => (sink) => {

     

       595
        
           let outerTalkback = talkbackPlaceholder;

     

       596
        
           let innerTalkback = talkbackPlaceholder;

     

       597
        
           let outerPulled = false;

     
···

       600
        
           let ended = false;

     

       601
        
           function applyInnerSource(innerSource: Source<Out>): void {

     

       602
        
             innerActive = true;

     

       603
       -
             innerSource((signal) => {

     

       604
        
               if (!innerActive) {

     

       605
        
                 /*noop*/

     

       606
        
               } else if (signal === SignalKind.End) {

     
···

       624
        
               }

     

       625
        
             });

     

       626
        
           }

     

       627
       -
           source((signal) => {

     

       628
        
             if (ended) {

     

       629
        
               /*noop*/

     

       630
        
             } else if (signal === SignalKind.End) {

     

       631
        
               ended = true;

     

       632
       -
               if (!innerActive)

     

       633
       -
                 sink(SignalKind.End);

     

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

     

       635
        
               outerTalkback = signal[0];

     

       636
        
             } else {

     
···

       647
        
               applyInnerSource(map(signal[0]));

     

       648
        
             }

     

       649
        
           });

     

       650
       -
           sink(start((signal) => {

     

       651
       -
             if (signal === TalkbackKind.Close) {

     

       652
       -
               if (!ended) {

     

       653
       -
                 ended = true;

     

       654
       -
                 outerTalkback(TalkbackKind.Close);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       655
        
               }

     

       656
       -
               if (innerActive) {

     

       657
       -
                 innerActive = false;

     

       658
       -
                 innerTalkback(TalkbackKind.Close);

     

       659
       -
               }

     

       660
       -
             } else {

     

       661
       -
               if (!ended && !outerPulled) {

     

       662
       -
                 outerPulled = true;

     

       663
       -
                 outerTalkback(TalkbackKind.Pull);

     

       664
       -
               }

     

       665
       -
               if (innerActive && !innerPulled) {

     

       666
       -
                 innerPulled = true;

     

       667
       -
                 innerTalkback(TalkbackKind.Pull);

     

       668
       -
               }

     

       669
       -
             }

     

       670
       -
           }));

     

       671
        
         };

     

       672
        
       }

     

       673
        
       

     
···

       676
        
       }

     

       677
        
       

     

       678
        
       export function take<T>(max: number): Operator<T, T> {

     

       679
       -
         return (source) => (sink) => {

     

       680
        
           let talkback = talkbackPlaceholder;

     

       681
        
           let ended = false;

     

       682
        
           let taken = 0;

     

       683
       -
           source((signal) => {

     

       684
        
             if (ended) {

     

       685
        
               /*noop*/

     

       686
        
             } else if (signal === SignalKind.End) {

     
···

       705
        
               sink(signal);

     

       706
        
             }

     

       707
        
           });

     

       708
       -
           sink(start((signal) => {

     

       709
       -
             if (signal === TalkbackKind.Close && !ended) {

     

       710
       -
               ended = true;

     

       711
       -
               talkback(TalkbackKind.Close);

     

       712
       -
             } else if (signal === TalkbackKind.Pull && !ended && taken < max) {

     

       713
       -
               talkback(TalkbackKind.Pull);

     

       714
       -
             }

     

       715
       -
           }));

     

       0
        
       
     

       0
        
       
     

       716
        
         };

     

       717
        
       }

     

       718
        
       

     

       719
        
       export function takeLast<T>(max: number): Operator<T, T> {

     

       720
       -
         return (source) => (sink) => {

     

       721
        
           const queue: T[] = [];

     

       722
        
           let talkback = talkbackPlaceholder;

     

       723
       -
           source((signal) => {

     

       724
        
             if (signal === SignalKind.End) {

     

       725
        
               fromArray(queue)(sink);

     

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

     
···

       740
        
       }

     

       741
        
       

     

       742
        
       export function takeUntil<S, T>(notifier: Source<S>): Operator<T, T> {

     

       743
       -
         return (source) => (sink) => {

     

       744
        
           let sourceTalkback = talkbackPlaceholder;

     

       745
        
           let notifierTalkback = talkbackPlaceholder;

     

       746
        
           let ended = false;

     

       747
       -
           source((signal) => {

     

       748
        
             if (ended) {

     

       749
        
               /*noop*/

     

       750
        
             } else if (signal === SignalKind.End) {

     
···

       753
        
               sink(SignalKind.End);

     

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

     

       755
        
               sourceTalkback = signal[0];

     

       756
       -
               notifier((signal) => {

     

       757
        
                 if (signal === SignalKind.End) {

     

       758
        
                   /*noop*/

     

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

     
···

       768
        
               sink(signal);

     

       769
        
             }

     

       770
        
           });

     

       771
       -
           sink(start((signal) => {

     

       772
       -
             if (signal === TalkbackKind.Close && !ended) {

     

       773
       -
               ended = true;

     

       774
       -
               sourceTalkback(TalkbackKind.Close);

     

       775
       -
               notifierTalkback(TalkbackKind.Close);

     

       776
       -
             } else if (!ended) {

     

       777
       -
               sourceTalkback(TalkbackKind.Pull);

     

       778
       -
             }

     

       779
       -
           }));

     

       0
        
       
     

       0
        
       
     

       780
        
         };

     

       781
        
       }

     

       782
        
       

     

       783
        
       export function takeWhile<T>(predicate: (value: T) => boolean): Operator<T, T> {

     

       784
       -
         return (source) => (sink) => {

     

       785
        
           let talkback = talkbackPlaceholder;

     

       786
        
           let ended = false;

     

       787
       -
           source((signal) => {

     

       788
        
             if (ended) {

     

       789
        
               /*noop*/

     

       790
        
             } else if (signal === SignalKind.End) {

     
···

       805
        
       }

     

       806
        
       

     

       807
        
       export function debounce<T>(timing: (value: T) => number): Operator<T, T> {

     

       808
       -
         return (source) => (sink) => {

     

       809
        
           let id: any | void;

     

       810
        
           let deferredEnded = false;

     

       811
        
           let ended = false;

     

       812
       -
           source((signal) => {

     

       813
        
             if (ended) {

     

       814
        
               /*noop*/

     

       815
        
             } else if (signal === SignalKind.End) {

     
···

       821
        
               }

     

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

     

       823
        
               const talkback = signal[0];

     

       824
       -
               sink(start((signal) => {

     

       825
       -
                 if (signal === TalkbackKind.Close && !ended) {

     

       826
       -
                   ended = true;

     

       827
       -
                   deferredEnded = false;

     

       828
       -
                   if (id) clearTimeout(id);

     

       829
       -
                   talkback(TalkbackKind.Close);

     

       830
       -
                 } else if (!ended) {

     

       831
       -
                   talkback(TalkbackKind.Pull);

     

       832
       -
                 }

     

       833
       -
               }));

     

       0
        
       
     

       0
        
       
     

       834
        
             } else {

     

       835
        
               if (id) clearTimeout(id);

     

       836
        
               id = setTimeout(() => {

     
···

       844
        
       }

     

       845
        
       

     

       846
        
       export function delay<T>(wait: number): Operator<T, T> {

     

       847
       -
         return (source) => (sink) => {

     

       848
        
           let active = 0;

     

       849
       -
           source((signal) => {

     

       850
        
             if (typeof signal !== 'number' && signal.tag === SignalKind.Start) {

     

       851
        
               sink(signal);

     

       852
        
             } else {

     
···

       863
        
       }

     

       864
        
       

     

       865
        
       export function throttle<T>(timing: (value: T) => number): Operator<T, T> {

     

       866
       -
         return (source) => (sink) => {

     

       867
        
           let skip = false;

     

       868
        
           let id: any | void;

     

       869
       -
           source((signal) => {

     

       870
        
             if (signal === SignalKind.End) {

     

       871
        
               if (id) clearTimeout(id);

     

       872
        
               sink(SignalKind.End);

     

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

     

       874
        
               const talkback = signal[0];

     

       875
       -
               sink(start((signal) => {

     

       876
       -
                 if (signal === TalkbackKind.Close) {

     

       877
       -
                   if (id) clearTimeout(id);

     

       878
       -
                   talkback(TalkbackKind.Close);

     

       879
       -
                 } else {

     

       880
       -
                   talkback(TalkbackKind.Pull);

     

       881
       -
                 }

     

       882
       -
               }));

     

       0
        
       
     

       0
        
       
     

       883
        
             } else if (!skip) {

     

       884
        
               skip = true;

     

       885
        
               if (id) clearTimeout(id);

     
···

       893
        
         };

     

       894
        
       }

     

       895
        
       

     

       896
       -
       export {

     

       897
       -
         mergeAll as flatten,

     

       898
       -
         onPush as tap,

     

       899
       -
       }

···

       1
       +
       import { Source, Sink, Operator, SignalKind, TalkbackKind, TalkbackFn } from './types';

     

       2
       +
       import { push, start, talkbackPlaceholder } from './helpers';

     

       3
       +
       import { fromArray } from './sources';

     

       4
        
       

     

       5
        
       const identity = <T>(x: T): T => x;

     

       6
        
       

     

       7
        
       export function buffer<S, T>(notifier: Source<S>): Operator<T, T[]> {

     

       8
       +
         return source => sink => {

     

       9
        
           let buffer: T[] = [];

     

       10
        
           let sourceTalkback = talkbackPlaceholder;

     

       11
        
           let notifierTalkback = talkbackPlaceholder;

     

       12
        
           let pulled = false;

     

       13
        
           let ended = false;

     

       14
       +
           source(signal => {

     

       15
        
             if (ended) {

     

       16
        
               /*noop*/

     

       17
        
             } else if (signal === SignalKind.End) {

     
···

       21
        
               sink(SignalKind.End);

     

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

     

       23
        
               sourceTalkback = signal[0];

     

       24
       +
               notifier(signal => {

     

       25
        
                 if (ended) {

     

       26
        
                   /*noop*/

     

       27
        
                 } else if (signal === SignalKind.End) {

     
···

       48
        
               }

     

       49
        
             }

     

       50
        
           });

     

       51
       +
           sink(

     

       52
       +
             start(signal => {

     

       53
       +
               if (signal === TalkbackKind.Close && !ended) {

     

       54
       +
                 ended = true;

     

       55
       +
                 sourceTalkback(TalkbackKind.Close);

     

       56
       +
                 notifierTalkback(TalkbackKind.Close);

     

       57
       +
               } else if (!ended && !pulled) {

     

       58
       +
                 pulled = true;

     

       59
       +
                 sourceTalkback(TalkbackKind.Pull);

     

       60
       +
                 notifierTalkback(TalkbackKind.Pull);

     

       61
       +
               }

     

       62
       +
             })

     

       63
       +
           );

     

       64
        
         };

     

       65
        
       }

     

       66
        
       

     

       67
        
       export function combine<A, B>(sourceA: Source<A>, sourceB: Source<B>): Source<[A, B]> {

     

       68
       +
         return sink => {

     

       69
        
           let lastValA: A | void;

     

       70
        
           let lastValB: B | void;

     

       71
        
           let talkbackA = talkbackPlaceholder;

     
···

       73
        
           let gotSignal = false;

     

       74
        
           let gotEnd = false;

     

       75
        
           let ended = false;

     

       76
       +
           sourceA(signal => {

     

       77
        
             if (signal === SignalKind.End) {

     

       78
        
               if (!gotEnd) {

     

       79
        
                 gotEnd = true;

     
···

       96
        
               sink(push([lastValA, lastValB] as [A, B]));

     

       97
        
             }

     

       98
        
           });

     

       99
       +
           sourceB(signal => {

     

       100
        
             if (signal === SignalKind.End) {

     

       101
        
               if (!gotEnd) {

     

       102
        
                 gotEnd = true;

     
···

       119
        
               sink(push([lastValA, lastValB] as [A, B]));

     

       120
        
             }

     

       121
        
           });

     

       122
       +
           sink(

     

       123
       +
             start(signal => {

     

       124
       +
               if (ended) {

     

       125
       +
                 /*noop*/

     

       126
       +
               } else if (signal === TalkbackKind.Close) {

     

       127
       +
                 ended = true;

     

       128
       +
                 talkbackA(TalkbackKind.Close);

     

       129
       +
                 talkbackB(TalkbackKind.Close);

     

       130
       +
               } else if (!gotSignal) {

     

       131
       +
                 gotSignal = true;

     

       132
       +
                 talkbackA(TalkbackKind.Pull);

     

       133
       +
                 talkbackB(TalkbackKind.Pull);

     

       134
       +
               }

     

       135
       +
             })

     

       136
       +
           );

     

       137
        
         };

     

       138
        
       }

     

       139
        
       

     

       140
        
       export function concatMap<In, Out>(map: (value: In) => Source<Out>): Operator<In, Out> {

     

       141
       +
         return source => sink => {

     

       142
        
           const inputQueue: In[] = [];

     

       143
        
           let outerTalkback = talkbackPlaceholder;

     

       144
        
           let innerTalkback = talkbackPlaceholder;

     
···

       148
        
           let ended = false;

     

       149
        
           function applyInnerSource(innerSource: Source<Out>): void {

     

       150
        
             innerActive = true;

     

       151
       +
             innerSource(signal => {

     

       152
        
               if (signal === SignalKind.End) {

     

       153
        
                 if (innerActive) {

     

       154
        
                   innerActive = false;

     

       155
        
                   if (inputQueue.length) {

     

       156
       +
                     applyInnerSource(map(inputQueue.shift()!));

     

       157
        
                   } else if (ended) {

     

       158
        
                     sink(SignalKind.End);

     

       159
        
                   } else if (!outerPulled) {

     
···

       174
        
               }

     

       175
        
             });

     

       176
        
           }

     

       177
       +
           source(signal => {

     

       178
        
             if (ended) {

     

       179
        
               /*noop*/

     

       180
        
             } else if (signal === SignalKind.End) {

     

       181
        
               ended = true;

     

       182
       +
               if (!innerActive && !inputQueue.length) sink(SignalKind.End);

     

       0
        
       
     

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

     

       184
        
               outerTalkback = signal[0];

     

       185
        
             } else {

     
···

       191
        
               }

     

       192
        
             }

     

       193
        
           });

     

       194
       +
           sink(

     

       195
       +
             start(signal => {

     

       196
       +
               if (signal === TalkbackKind.Close) {

     

       197
       +
                 if (!ended) {

     

       198
       +
                   ended = true;

     

       199
       +
                   outerTalkback(TalkbackKind.Close);

     

       200
       +
                 }

     

       201
       +
                 if (innerActive) {

     

       202
       +
                   innerActive = false;

     

       203
       +
                   innerTalkback(TalkbackKind.Close);

     

       204
       +
                 }

     

       205
       +
               } else {

     

       206
       +
                 if (!ended && !outerPulled) {

     

       207
       +
                   outerPulled = true;

     

       208
       +
                   outerTalkback(TalkbackKind.Pull);

     

       209
       +
                 }

     

       210
       +
                 if (innerActive && !innerPulled) {

     

       211
       +
                   innerPulled = true;

     

       212
       +
                   innerTalkback(TalkbackKind.Pull);

     

       213
       +
                 }

     

       214
        
               }

     

       215
       +
             })

     

       216
       +
           );

     

       217
        
         };

     

       218
        
       }

     

       219
        
       

     
···

       226
        
       }

     

       227
        
       

     

       228
        
       export function filter<T>(predicate: (value: T) => boolean): Operator<T, T> {

     

       229
       +
         return source => sink => {

     

       230
        
           let talkback = talkbackPlaceholder;

     

       231
       +
           source(signal => {

     

       232
        
             if (signal === SignalKind.End) {

     

       233
        
               sink(signal);

     

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

     
···

       244
        
       }

     

       245
        
       

     

       246
        
       export function map<In, Out>(map: (value: In) => Out): Operator<In, Out> {

     

       247
       +
         return source => sink =>

     

       248
       +
           source(signal => {

     

       249
       +
             if (signal === SignalKind.End || signal.tag === SignalKind.Start) {

     

       250
       +
               sink(signal);

     

       251
       +
             } else {

     

       252
       +
               sink(push(map(signal[0])));

     

       253
       +
             }

     

       254
       +
           });

     

       255
        
       }

     

       256
        
       

     

       257
        
       export function mergeMap<In, Out>(map: (value: In) => Source<Out>): Operator<In, Out> {

     

       258
       +
         return source => sink => {

     

       259
        
           const innerTalkbacks: TalkbackFn[] = [];

     

       260
        
           let outerTalkback = talkbackPlaceholder;

     

       261
        
           let outerPulled = false;

     

       262
        
           let ended = false;

     

       263
        
           function applyInnerSource(innerSource: Source<Out>): void {

     

       264
        
             let talkback = talkbackPlaceholder;

     

       265
       +
             innerSource(signal => {

     

       266
        
               if (signal === SignalKind.End) {

     

       267
        
                 if (innerTalkbacks.length) {

     

       268
        
                   const index = innerTalkbacks.indexOf(talkback);

     
···

       277
        
                   }

     

       278
        
                 }

     

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

     

       280
       +
                 innerTalkbacks.push((talkback = signal[0]));

     

       281
        
                 talkback(TalkbackKind.Pull);

     

       282
        
               } else if (innerTalkbacks.length) {

     

       283
        
                 sink(signal);

     
···

       285
        
               }

     

       286
        
             });

     

       287
        
           }

     

       288
       +
           source(signal => {

     

       289
        
             if (ended) {

     

       290
        
               /*noop*/

     

       291
        
             } else if (signal === SignalKind.End) {

     

       292
        
               ended = true;

     

       293
       +
               if (!innerTalkbacks.length) sink(SignalKind.End);

     

       0
        
       
     

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

     

       295
        
               outerTalkback = signal[0];

     

       296
        
             } else {

     
···

       302
        
               }

     

       303
        
             }

     

       304
        
           });

     

       305
       +
           sink(

     

       306
       +
             start(signal => {

     

       307
       +
               if (signal === TalkbackKind.Close) {

     

       308
       +
                 if (!ended) {

     

       309
       +
                   ended = true;

     

       310
       +
                   outerTalkback(TalkbackKind.Close);

     

       311
       +
                 }

     

       312
       +
                 while (innerTalkbacks.length) innerTalkbacks.pop()!(TalkbackKind.Close);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       313
        
               } else {

     

       314
       +
                 if (!ended && !outerPulled) {

     

       315
       +
                   outerPulled = true;

     

       316
       +
                   outerTalkback(TalkbackKind.Pull);

     

       317
       +
                 } else {

     

       318
       +
                   outerPulled = false;

     

       319
       +
                 }

     

       320
       +
                 for (let i = 0; i < innerTalkbacks.length; i++) innerTalkbacks[i](TalkbackKind.Pull);

     

       321
        
               }

     

       322
       +
             })

     

       323
       +
           );

     

       0
        
       
     

       0
        
       
     

       324
        
         };

     

       325
        
       }

     

       326
        
       

     
···

       333
        
       }

     

       334
        
       

     

       335
        
       export function onEnd<T>(callback: () => void): Operator<T, T> {

     

       336
       +
         return source => sink => {

     

       337
        
           let ended = false;

     

       338
       +
           source(signal => {

     

       339
        
             if (ended) {

     

       340
        
               /*noop*/

     

       341
        
             } else if (signal === SignalKind.End) {

     
···

       344
        
               callback();

     

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

     

       346
        
               const talkback = signal[0];

     

       347
       +
               sink(

     

       348
       +
                 start(signal => {

     

       349
       +
                   if (signal === TalkbackKind.Close) {

     

       350
       +
                     ended = true;

     

       351
       +
                     talkback(TalkbackKind.Close);

     

       352
       +
                     callback();

     

       353
       +
                   } else {

     

       354
       +
                     talkback(signal);

     

       355
       +
                   }

     

       356
       +
                 })

     

       357
       +
               );

     

       358
        
             } else {

     

       359
        
               sink(signal);

     

       360
        
             }

     
···

       363
        
       }

     

       364
        
       

     

       365
        
       export function onPush<T>(callback: (value: T) => void): Operator<T, T> {

     

       366
       +
         return source => sink => {

     

       367
        
           let ended = false;

     

       368
       +
           source(signal => {

     

       369
        
             if (ended) {

     

       370
        
               /*noop*/

     

       371
        
             } else if (signal === SignalKind.End) {

     
···

       373
        
               sink(SignalKind.End);

     

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

     

       375
        
               const talkback = signal[0];

     

       376
       +
               sink(

     

       377
       +
                 start(signal => {

     

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

     

       379
       +
                   talkback(signal);

     

       380
       +
                 })

     

       381
       +
               );

     

       382
        
             } else {

     

       383
        
               callback(signal[0]);

     

       384
        
               sink(signal);

     
···

       388
        
       }

     

       389
        
       

     

       390
        
       export function onStart<T>(callback: () => void): Operator<T, T> {

     

       391
       +
         return source => sink =>

     

       392
       +
           source(signal => {

     

       393
       +
             if (signal === SignalKind.End) {

     

       394
       +
               sink(SignalKind.End);

     

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

     

       396
       +
               sink(signal);

     

       397
       +
               callback();

     

       398
       +
             } else {

     

       399
       +
               sink(signal);

     

       400
       +
             }

     

       401
       +
           });

     

       402
        
       }

     

       403
        
       

     

       404
        
       export function sample<S, T>(notifier: Source<S>): Operator<T, T> {

     

       405
       +
         return source => sink => {

     

       406
        
           let sourceTalkback = talkbackPlaceholder;

     

       407
        
           let notifierTalkback = talkbackPlaceholder;

     

       408
        
           let value: T | void;

     

       409
        
           let pulled = false;

     

       410
        
           let ended = false;

     

       411
       +
           source(signal => {

     

       412
        
             if (ended) {

     

       413
        
               /*noop*/

     

       414
        
             } else if (signal === SignalKind.End) {

     
···

       428
        
               }

     

       429
        
             }

     

       430
        
           });

     

       431
       +
           notifier(signal => {

     

       432
        
             if (ended) {

     

       433
        
               /*noop*/

     

       434
        
             } else if (signal === SignalKind.End) {

     
···

       443
        
               sink(signal);

     

       444
        
             }

     

       445
        
           });

     

       446
       +
           sink(

     

       447
       +
             start(signal => {

     

       448
       +
               if (signal === TalkbackKind.Close && !ended) {

     

       449
       +
                 ended = true;

     

       450
       +
                 sourceTalkback(TalkbackKind.Close);

     

       451
       +
                 notifierTalkback(TalkbackKind.Close);

     

       452
       +
               } else if (!ended && !pulled) {

     

       453
       +
                 pulled = true;

     

       454
       +
                 sourceTalkback(TalkbackKind.Pull);

     

       455
       +
                 notifierTalkback(TalkbackKind.Pull);

     

       456
       +
               }

     

       457
       +
             })

     

       458
       +
           );

     

       459
        
         };

     

       460
        
       }

     

       461
        
       

     

       462
        
       export function scan<In, Out>(reducer: (acc: Out, value: In) => Out, seed: Out): Operator<In, Out> {

     

       463
       +
         return source => sink => {

     

       464
        
           let acc = seed;

     

       465
       +
           source(signal => {

     

       466
        
             if (signal === SignalKind.End) {

     

       467
        
               sink(SignalKind.End);

     

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

     

       469
        
               sink(signal);

     

       470
        
             } else {

     

       471
       +
               sink(push((acc = reducer(acc, signal[0]))));

     

       472
        
             }

     

       473
        
           });

     

       474
        
         };

     
···

       478
        
         const sinks: Sink<T>[] = [];

     

       479
        
         let talkback = talkbackPlaceholder;

     

       480
        
         let gotSignal = false;

     

       481
       +
         return sink => {

     

       482
        
           sinks.push(sink);

     

       483
        
           if (sinks.length === 1) {

     

       484
       +
             source(signal => {

     

       485
        
               if (signal === SignalKind.End) {

     

       486
        
                 while (sinks.length) sinks.pop()!(SignalKind.End);

     

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

     
···

       492
        
               }

     

       493
        
             });

     

       494
        
           }

     

       495
       +
           sink(

     

       496
       +
             start(signal => {

     

       497
       +
               if (signal === TalkbackKind.Close) {

     

       498
       +
                 const index = sinks.indexOf(sink);

     

       499
       +
                 if (index > -1) sinks.splice(index, 1);

     

       500
       +
                 if (!sinks.length) talkback(TalkbackKind.Close);

     

       501
       +
               } else if (signal === TalkbackKind.Pull && !gotSignal) {

     

       502
       +
                 gotSignal = true;

     

       503
       +
                 talkback(TalkbackKind.Pull);

     

       504
       +
               }

     

       505
       +
             })

     

       506
       +
           );

     

       507
        
         };

     

       508
        
       }

     

       509
        
       

     

       510
        
       export function skip<T>(wait: number): Operator<T, T> {

     

       511
       +
         return source => sink => {

     

       512
        
           let talkback = talkbackPlaceholder;

     

       513
        
           let rest = wait;

     

       514
       +
           source(signal => {

     

       515
        
             if (signal === SignalKind.End) {

     

       516
        
               sink(SignalKind.End);

     

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

     
···

       527
        
       }

     

       528
        
       

     

       529
        
       export function skipUntil<S, T>(notifier: Source<S>): Operator<T, T> {

     

       530
       +
         return source => sink => {

     

       531
        
           let sourceTalkback = talkbackPlaceholder;

     

       532
        
           let notifierTalkback = talkbackPlaceholder;

     

       533
        
           let skip = true;

     

       534
        
           let pulled = false;

     

       535
        
           let ended = false;

     

       536
       +
           source(signal => {

     

       537
        
             if (ended) {

     

       538
        
               /*noop*/

     

       539
        
             } else if (signal === SignalKind.End) {

     
···

       542
        
               sink(SignalKind.End);

     

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

     

       544
        
               sourceTalkback = signal[0];

     

       545
       +
               notifier(signal => {

     

       546
        
                 if (signal === SignalKind.End) {

     

       547
        
                   if (skip) {

     

       548
        
                     ended = true;

     
···

       566
        
               pulled = false;

     

       567
        
             }

     

       568
        
           });

     

       569
       +
           sink(

     

       570
       +
             start(signal => {

     

       571
       +
               if (signal === TalkbackKind.Close && !ended) {

     

       572
       +
                 ended = true;

     

       573
       +
                 sourceTalkback(TalkbackKind.Close);

     

       574
       +
                 if (skip) notifierTalkback(TalkbackKind.Close);

     

       575
       +
               } else if (!ended && !pulled) {

     

       576
       +
                 pulled = true;

     

       577
       +
                 if (skip) notifierTalkback(TalkbackKind.Pull);

     

       578
       +
                 sourceTalkback(TalkbackKind.Pull);

     

       579
       +
               }

     

       580
       +
             })

     

       581
       +
           );

     

       582
        
         };

     

       583
        
       }

     

       584
        
       

     

       585
        
       export function skipWhile<T>(predicate: (value: T) => boolean): Operator<T, T> {

     

       586
       +
         return source => sink => {

     

       587
        
           let talkback = talkbackPlaceholder;

     

       588
        
           let skip = true;

     

       589
       +
           source(signal => {

     

       590
        
             if (signal === SignalKind.End) {

     

       591
        
               sink(SignalKind.End);

     

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

     
···

       607
        
       }

     

       608
        
       

     

       609
        
       export function switchMap<In, Out>(map: (value: In) => Source<Out>): Operator<In, Out> {

     

       610
       +
         return source => sink => {

     

       611
        
           let outerTalkback = talkbackPlaceholder;

     

       612
        
           let innerTalkback = talkbackPlaceholder;

     

       613
        
           let outerPulled = false;

     
···

       616
        
           let ended = false;

     

       617
        
           function applyInnerSource(innerSource: Source<Out>): void {

     

       618
        
             innerActive = true;

     

       619
       +
             innerSource(signal => {

     

       620
        
               if (!innerActive) {

     

       621
        
                 /*noop*/

     

       622
        
               } else if (signal === SignalKind.End) {

     
···

       640
        
               }

     

       641
        
             });

     

       642
        
           }

     

       643
       +
           source(signal => {

     

       644
        
             if (ended) {

     

       645
        
               /*noop*/

     

       646
        
             } else if (signal === SignalKind.End) {

     

       647
        
               ended = true;

     

       648
       +
               if (!innerActive) sink(SignalKind.End);

     

       0
        
       
     

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

     

       650
        
               outerTalkback = signal[0];

     

       651
        
             } else {

     
···

       662
        
               applyInnerSource(map(signal[0]));

     

       663
        
             }

     

       664
        
           });

     

       665
       +
           sink(

     

       666
       +
             start(signal => {

     

       667
       +
               if (signal === TalkbackKind.Close) {

     

       668
       +
                 if (!ended) {

     

       669
       +
                   ended = true;

     

       670
       +
                   outerTalkback(TalkbackKind.Close);

     

       671
       +
                 }

     

       672
       +
                 if (innerActive) {

     

       673
       +
                   innerActive = false;

     

       674
       +
                   innerTalkback(TalkbackKind.Close);

     

       675
       +
                 }

     

       676
       +
               } else {

     

       677
       +
                 if (!ended && !outerPulled) {

     

       678
       +
                   outerPulled = true;

     

       679
       +
                   outerTalkback(TalkbackKind.Pull);

     

       680
       +
                 }

     

       681
       +
                 if (innerActive && !innerPulled) {

     

       682
       +
                   innerPulled = true;

     

       683
       +
                   innerTalkback(TalkbackKind.Pull);

     

       684
       +
                 }

     

       685
        
               }

     

       686
       +
             })

     

       687
       +
           );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       688
        
         };

     

       689
        
       }

     

       690
        
       

     
···

       693
        
       }

     

       694
        
       

     

       695
        
       export function take<T>(max: number): Operator<T, T> {

     

       696
       +
         return source => sink => {

     

       697
        
           let talkback = talkbackPlaceholder;

     

       698
        
           let ended = false;

     

       699
        
           let taken = 0;

     

       700
       +
           source(signal => {

     

       701
        
             if (ended) {

     

       702
        
               /*noop*/

     

       703
        
             } else if (signal === SignalKind.End) {

     
···

       722
        
               sink(signal);

     

       723
        
             }

     

       724
        
           });

     

       725
       +
           sink(

     

       726
       +
             start(signal => {

     

       727
       +
               if (signal === TalkbackKind.Close && !ended) {

     

       728
       +
                 ended = true;

     

       729
       +
                 talkback(TalkbackKind.Close);

     

       730
       +
               } else if (signal === TalkbackKind.Pull && !ended && taken < max) {

     

       731
       +
                 talkback(TalkbackKind.Pull);

     

       732
       +
               }

     

       733
       +
             })

     

       734
       +
           );

     

       735
        
         };

     

       736
        
       }

     

       737
        
       

     

       738
        
       export function takeLast<T>(max: number): Operator<T, T> {

     

       739
       +
         return source => sink => {

     

       740
        
           const queue: T[] = [];

     

       741
        
           let talkback = talkbackPlaceholder;

     

       742
       +
           source(signal => {

     

       743
        
             if (signal === SignalKind.End) {

     

       744
        
               fromArray(queue)(sink);

     

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

     
···

       759
        
       }

     

       760
        
       

     

       761
        
       export function takeUntil<S, T>(notifier: Source<S>): Operator<T, T> {

     

       762
       +
         return source => sink => {

     

       763
        
           let sourceTalkback = talkbackPlaceholder;

     

       764
        
           let notifierTalkback = talkbackPlaceholder;

     

       765
        
           let ended = false;

     

       766
       +
           source(signal => {

     

       767
        
             if (ended) {

     

       768
        
               /*noop*/

     

       769
        
             } else if (signal === SignalKind.End) {

     
···

       772
        
               sink(SignalKind.End);

     

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

     

       774
        
               sourceTalkback = signal[0];

     

       775
       +
               notifier(signal => {

     

       776
        
                 if (signal === SignalKind.End) {

     

       777
        
                   /*noop*/

     

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

     
···

       787
        
               sink(signal);

     

       788
        
             }

     

       789
        
           });

     

       790
       +
           sink(

     

       791
       +
             start(signal => {

     

       792
       +
               if (signal === TalkbackKind.Close && !ended) {

     

       793
       +
                 ended = true;

     

       794
       +
                 sourceTalkback(TalkbackKind.Close);

     

       795
       +
                 notifierTalkback(TalkbackKind.Close);

     

       796
       +
               } else if (!ended) {

     

       797
       +
                 sourceTalkback(TalkbackKind.Pull);

     

       798
       +
               }

     

       799
       +
             })

     

       800
       +
           );

     

       801
        
         };

     

       802
        
       }

     

       803
        
       

     

       804
        
       export function takeWhile<T>(predicate: (value: T) => boolean): Operator<T, T> {

     

       805
       +
         return source => sink => {

     

       806
        
           let talkback = talkbackPlaceholder;

     

       807
        
           let ended = false;

     

       808
       +
           source(signal => {

     

       809
        
             if (ended) {

     

       810
        
               /*noop*/

     

       811
        
             } else if (signal === SignalKind.End) {

     
···

       826
        
       }

     

       827
        
       

     

       828
        
       export function debounce<T>(timing: (value: T) => number): Operator<T, T> {

     

       829
       +
         return source => sink => {

     

       830
        
           let id: any | void;

     

       831
        
           let deferredEnded = false;

     

       832
        
           let ended = false;

     

       833
       +
           source(signal => {

     

       834
        
             if (ended) {

     

       835
        
               /*noop*/

     

       836
        
             } else if (signal === SignalKind.End) {

     
···

       842
        
               }

     

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

     

       844
        
               const talkback = signal[0];

     

       845
       +
               sink(

     

       846
       +
                 start(signal => {

     

       847
       +
                   if (signal === TalkbackKind.Close && !ended) {

     

       848
       +
                     ended = true;

     

       849
       +
                     deferredEnded = false;

     

       850
       +
                     if (id) clearTimeout(id);

     

       851
       +
                     talkback(TalkbackKind.Close);

     

       852
       +
                   } else if (!ended) {

     

       853
       +
                     talkback(TalkbackKind.Pull);

     

       854
       +
                   }

     

       855
       +
                 })

     

       856
       +
               );

     

       857
        
             } else {

     

       858
        
               if (id) clearTimeout(id);

     

       859
        
               id = setTimeout(() => {

     
···

       867
        
       }

     

       868
        
       

     

       869
        
       export function delay<T>(wait: number): Operator<T, T> {

     

       870
       +
         return source => sink => {

     

       871
        
           let active = 0;

     

       872
       +
           source(signal => {

     

       873
        
             if (typeof signal !== 'number' && signal.tag === SignalKind.Start) {

     

       874
        
               sink(signal);

     

       875
        
             } else {

     
···

       886
        
       }

     

       887
        
       

     

       888
        
       export function throttle<T>(timing: (value: T) => number): Operator<T, T> {

     

       889
       +
         return source => sink => {

     

       890
        
           let skip = false;

     

       891
        
           let id: any | void;

     

       892
       +
           source(signal => {

     

       893
        
             if (signal === SignalKind.End) {

     

       894
        
               if (id) clearTimeout(id);

     

       895
        
               sink(SignalKind.End);

     

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

     

       897
        
               const talkback = signal[0];

     

       898
       +
               sink(

     

       899
       +
                 start(signal => {

     

       900
       +
                   if (signal === TalkbackKind.Close) {

     

       901
       +
                     if (id) clearTimeout(id);

     

       902
       +
                     talkback(TalkbackKind.Close);

     

       903
       +
                   } else {

     

       904
       +
                     talkback(TalkbackKind.Pull);

     

       905
       +
                   }

     

       906
       +
                 })

     

       907
       +
               );

     

       908
        
             } else if (!skip) {

     

       909
        
               skip = true;

     

       910
        
               if (id) clearTimeout(id);

     
···

       918
        
         };

     

       919
        
       }

     

       920
        
       

     

       921
       +
       export { mergeAll as flatten, onPush as tap };

     

       0
        
       
     

       0
        
       
     

       0

+1 -2

src/pipe.ts

···

       153
        
       

     

       154
        
       function pipe() {

     

       155
        
         let x = arguments[0];

     

       156
       -
         for (let i = 1, l = arguments.length; i < l; i++)

     

       157
       -
           x = arguments[i](x);

     

       158
        
         return x;

     

       159
        
       }

     

       160

···

       153
        
       

     

       154
        
       function pipe() {

     

       155
        
         let x = arguments[0];

     

       156
       +
         for (let i = 1, l = arguments.length; i < l; i++) x = arguments[i](x);

     

       0
        
       
     

       157
        
         return x;

     

       158
        
       }

     

       159

+11 -9

src/sinks.ts

···

       1
       -
       import { Source, Subscription, TalkbackKind, SignalKind } from './types'

     

       2
       -
       import { talkbackPlaceholder } from './helpers'

     

       3
        
       

     

       4
        
       export function subscribe<T>(subscriber: (value: T) => void) {

     

       5
        
         return (source: Source<T>): Subscription => {

     

       6
        
           let talkback = talkbackPlaceholder;

     

       7
        
           let ended = false;

     

       8
       -
           source((signal) => {

     

       9
        
             if (signal === SignalKind.End) {

     

       10
        
               ended = true;

     

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

     
···

       22
        
                 talkback(TalkbackKind.Close);

     

       23
        
               }

     

       24
        
             },

     

       25
       -
           }

     

       26
       -
         }

     

       27
        
       }

     

       28
        
       

     

       29
        
       export function forEach<T>(subscriber: (value: T) => void) {

     
···

       33
        
       }

     

       34
        
       

     

       35
        
       export function publish<T>(source: Source<T>): void {

     

       36
       -
         subscribe((_value) => {/*noop*/})(source);

     

       0
        
       
     

       0
        
       
     

       37
        
       }

     

       38
        
       

     

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

     

       40
        
         const values: T[] = [];

     

       41
        
         let talkback = talkbackPlaceholder;

     

       42
        
         let ended = false;

     

       43
       -
         source((signal) => {

     

       44
        
           if (signal === SignalKind.End) {

     

       45
        
             ended = true;

     

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

     
···

       58
        
         return new Promise(resolve => {

     

       59
        
           let talkback = talkbackPlaceholder;

     

       60
        
           let value: T | void;

     

       61
       -
           source((signal) => {

     

       62
        
             if (signal === SignalKind.End) {

     

       63
        
               resolve(value!);

     

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

     
···

       68
        
               talkback(TalkbackKind.Pull);

     

       69
        
             }

     

       70
        
           });

     

       71
       -
         })

     

       72
        
       }

···

       1
       +
       import { Source, Subscription, TalkbackKind, SignalKind } from './types';

     

       2
       +
       import { talkbackPlaceholder } from './helpers';

     

       3
        
       

     

       4
        
       export function subscribe<T>(subscriber: (value: T) => void) {

     

       5
        
         return (source: Source<T>): Subscription => {

     

       6
        
           let talkback = talkbackPlaceholder;

     

       7
        
           let ended = false;

     

       8
       +
           source(signal => {

     

       9
        
             if (signal === SignalKind.End) {

     

       10
        
               ended = true;

     

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

     
···

       22
        
                 talkback(TalkbackKind.Close);

     

       23
        
               }

     

       24
        
             },

     

       25
       +
           };

     

       26
       +
         };

     

       27
        
       }

     

       28
        
       

     

       29
        
       export function forEach<T>(subscriber: (value: T) => void) {

     
···

       33
        
       }

     

       34
        
       

     

       35
        
       export function publish<T>(source: Source<T>): void {

     

       36
       +
         subscribe(_value => {

     

       37
       +
           /*noop*/

     

       38
       +
         })(source);

     

       39
        
       }

     

       40
        
       

     

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

     

       42
        
         const values: T[] = [];

     

       43
        
         let talkback = talkbackPlaceholder;

     

       44
        
         let ended = false;

     

       45
       +
         source(signal => {

     

       46
        
           if (signal === SignalKind.End) {

     

       47
        
             ended = true;

     

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

     
···

       60
        
         return new Promise(resolve => {

     

       61
        
           let talkback = talkbackPlaceholder;

     

       62
        
           let value: T | void;

     

       63
       +
           source(signal => {

     

       64
        
             if (signal === SignalKind.End) {

     

       65
        
               resolve(value!);

     

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

     
···

       70
        
               talkback(TalkbackKind.Pull);

     

       71
        
             }

     

       72
        
           });

     

       73
       +
         });

     

       74
        
       }

+84 -70

src/sources.ts

···

       1
       -
       import { Source, Sink, SignalKind, TalkbackKind, Observer, Subject, TeardownFn } from './types'

     

       2
       -
       import { push, start, talkbackPlaceholder } from './helpers'

     

       3
        
       

     

       4
        
       export function fromArray<T>(array: T[]): Source<T> {

     

       5
       -
         return (sink) => {

     

       6
        
           let ended = false;

     

       7
        
           let looping = false;

     

       8
        
           let pulled = false;

     

       9
        
           let current = 0;

     

       10
       -
           sink(start((signal) => {

     

       11
       -
             if (signal === TalkbackKind.Close) {

     

       12
       -
               ended = true;

     

       13
       -
             } else if (looping) {

     

       14
       -
               pulled = true;

     

       15
       -
             } else {

     

       16
       -
               pulled = true;

     

       17
       -
               looping = true;

     

       18
       -
               for (pulled = looping = true; pulled && !ended; current++) {

     

       19
       -
                 if (current < array.length) {

     

       20
       -
                   pulled = false;

     

       21
       -
                   sink(push(array[current]));

     

       22
       -
                 } else {

     

       23
       -
                   ended = true;

     

       24
       -
                   sink(SignalKind.End);

     

       0
        
       
     

       0
        
       
     

       25
        
                 }

     

       0
        
       
     

       26
        
               }

     

       27
       -
               looping = false;

     

       28
       -
             }

     

       29
       -
           }))

     

       30
       -
         }

     

       31
        
       }

     

       32
        
       

     

       33
        
       export function fromValue<T>(value: T): Source<T> {

     

       34
       -
         return (sink) => {

     

       35
        
           let ended = false;

     

       36
       -
           sink(start((signal) => {

     

       37
       -
             if (signal === TalkbackKind.Close) {

     

       38
       -
               ended = true;

     

       39
       -
             } else if (!ended) {

     

       40
       -
               ended = true;

     

       41
       -
               sink(push(value));

     

       42
       -
               sink(SignalKind.End);

     

       43
       -
             }

     

       44
       -
           }))

     

       45
       -
         }

     

       0
        
       
     

       0
        
       
     

       46
        
       }

     

       47
        
       

     

       48
        
       export function make<T>(produce: (observer: Observer<T>) => TeardownFn): Source<T> {

     

       49
       -
         return (sink) => {

     

       50
        
           let ended = false;

     

       51
        
           const teardown = produce({

     

       52
        
             next(value: T) {

     
···

       59
        
               }

     

       60
        
             },

     

       61
        
           });

     

       62
       -
           sink(start((signal) => {

     

       63
       -
             if (signal === TalkbackKind.Close && !ended) {

     

       64
       -
               ended = true;

     

       65
       -
               teardown();

     

       66
       -
             }

     

       67
       -
           }));

     

       68
       -
         }

     

       0
        
       
     

       0
        
       
     

       69
        
       }

     

       70
        
       

     

       71
        
       export function makeSubject<T>(): Subject<T> {

     
···

       74
        
         return {

     

       75
        
           source(sink: Sink<T>) {

     

       76
        
             sinks.push(sink);

     

       77
       -
             sink(start((signal) => {

     

       78
       -
               if (signal === TalkbackKind.Close) {

     

       79
       -
                 const index = sinks.indexOf(sink);

     

       80
       -
                 if (index > -1) sinks.splice(index, 1);

     

       81
       -
               }

     

       82
       -
             }));

     

       0
        
       
     

       0
        
       
     

       83
        
           },

     

       84
        
           next(value: T) {

     

       85
        
             if (!ended) {

     
···

       98
        
       

     

       99
        
       export const empty: Source<any> = (sink: Sink<any>): void => {

     

       100
        
         let ended = false;

     

       101
       -
         sink(start((signal) => {

     

       102
       -
           if (signal === TalkbackKind.Close) {

     

       103
       -
             ended = true;

     

       104
       -
           } else if (!ended) {

     

       105
       -
             ended = true;

     

       106
       -
             sink(SignalKind.End);

     

       107
       -
           }

     

       108
       -
         }));

     

       0
        
       
     

       0
        
       
     

       109
        
       };

     

       110
        
       

     

       111
        
       export const never: Source<any> = (sink: Sink<any>): void => {

     
···

       113
        
       };

     

       114
        
       

     

       115
        
       export function interval(ms: number): Source<number> {

     

       116
       -
         return (sink) => {

     

       117
        
           let i = 0;

     

       118
        
           const id = setInterval(() => {

     

       119
        
             sink(push(i++));

     

       120
        
           }, ms);

     

       121
       -
           sink(start((signal) => {

     

       122
       -
             if (signal === TalkbackKind.Close)

     

       123
       -
               clearInterval(id);

     

       124
       -
           }));

     

       0
        
       
     

       125
        
         };

     

       126
        
       }

     

       127
        
       

     

       128
        
       export function fromDomEvent(element: HTMLElement, event: string): Source<Event> {

     

       129
       -
         return (sink) => {

     

       130
        
           const handler = (payload: Event) => {

     

       131
        
             sink(push(payload));

     

       132
        
           };

     

       133
       -
           sink(start((signal) => {

     

       134
       -
             if (signal === TalkbackKind.Close)

     

       135
       -
               element.removeEventListener(event, handler);

     

       136
       -
           }));

     

       0
        
       
     

       137
        
           element.addEventListener(event, handler);

     

       138
        
         };

     

       139
        
       }

     

       140
        
       

     

       141
        
       export function fromPromise<T>(promise: Promise<T>): Source<T> {

     

       142
       -
         return (sink) => {

     

       143
        
           let ended = false;

     

       144
       -
           promise.then((value) => {

     

       145
        
             if (!ended) {

     

       146
        
               sink(push(value));

     

       147
        
               sink(SignalKind.End);

     

       148
        
             }

     

       149
        
           });

     

       150
       -
           sink(start((signal) => {

     

       151
       -
             if (signal === TalkbackKind.Close) ended = true;

     

       152
       -
           }));

     

       0
        
       
     

       0
        
       
     

       153
        
         };

     

       154
        
       }

···

       1
       +
       import { Source, Sink, SignalKind, TalkbackKind, Observer, Subject, TeardownFn } from './types';

     

       2
       +
       import { push, start, talkbackPlaceholder } from './helpers';

     

       3
        
       

     

       4
        
       export function fromArray<T>(array: T[]): Source<T> {

     

       5
       +
         return sink => {

     

       6
        
           let ended = false;

     

       7
        
           let looping = false;

     

       8
        
           let pulled = false;

     

       9
        
           let current = 0;

     

       10
       +
           sink(

     

       11
       +
             start(signal => {

     

       12
       +
               if (signal === TalkbackKind.Close) {

     

       13
       +
                 ended = true;

     

       14
       +
               } else if (looping) {

     

       15
       +
                 pulled = true;

     

       16
       +
               } else {

     

       17
       +
                 pulled = true;

     

       18
       +
                 looping = true;

     

       19
       +
                 for (pulled = looping = true; pulled && !ended; current++) {

     

       20
       +
                   if (current < array.length) {

     

       21
       +
                     pulled = false;

     

       22
       +
                     sink(push(array[current]));

     

       23
       +
                   } else {

     

       24
       +
                     ended = true;

     

       25
       +
                     sink(SignalKind.End);

     

       26
       +
                   }

     

       27
        
                 }

     

       28
       +
                 looping = false;

     

       29
        
               }

     

       30
       +
             })

     

       31
       +
           );

     

       32
       +
         };

     

       0
        
       
     

       33
        
       }

     

       34
        
       

     

       35
        
       export function fromValue<T>(value: T): Source<T> {

     

       36
       +
         return sink => {

     

       37
        
           let ended = false;

     

       38
       +
           sink(

     

       39
       +
             start(signal => {

     

       40
       +
               if (signal === TalkbackKind.Close) {

     

       41
       +
                 ended = true;

     

       42
       +
               } else if (!ended) {

     

       43
       +
                 ended = true;

     

       44
       +
                 sink(push(value));

     

       45
       +
                 sink(SignalKind.End);

     

       46
       +
               }

     

       47
       +
             })

     

       48
       +
           );

     

       49
       +
         };

     

       50
        
       }

     

       51
        
       

     

       52
        
       export function make<T>(produce: (observer: Observer<T>) => TeardownFn): Source<T> {

     

       53
       +
         return sink => {

     

       54
        
           let ended = false;

     

       55
        
           const teardown = produce({

     

       56
        
             next(value: T) {

     
···

       63
        
               }

     

       64
        
             },

     

       65
        
           });

     

       66
       +
           sink(

     

       67
       +
             start(signal => {

     

       68
       +
               if (signal === TalkbackKind.Close && !ended) {

     

       69
       +
                 ended = true;

     

       70
       +
                 teardown();

     

       71
       +
               }

     

       72
       +
             })

     

       73
       +
           );

     

       74
       +
         };

     

       75
        
       }

     

       76
        
       

     

       77
        
       export function makeSubject<T>(): Subject<T> {

     
···

       80
        
         return {

     

       81
        
           source(sink: Sink<T>) {

     

       82
        
             sinks.push(sink);

     

       83
       +
             sink(

     

       84
       +
               start(signal => {

     

       85
       +
                 if (signal === TalkbackKind.Close) {

     

       86
       +
                   const index = sinks.indexOf(sink);

     

       87
       +
                   if (index > -1) sinks.splice(index, 1);

     

       88
       +
                 }

     

       89
       +
               })

     

       90
       +
             );

     

       91
        
           },

     

       92
        
           next(value: T) {

     

       93
        
             if (!ended) {

     
···

       106
        
       

     

       107
        
       export const empty: Source<any> = (sink: Sink<any>): void => {

     

       108
        
         let ended = false;

     

       109
       +
         sink(

     

       110
       +
           start(signal => {

     

       111
       +
             if (signal === TalkbackKind.Close) {

     

       112
       +
               ended = true;

     

       113
       +
             } else if (!ended) {

     

       114
       +
               ended = true;

     

       115
       +
               sink(SignalKind.End);

     

       116
       +
             }

     

       117
       +
           })

     

       118
       +
         );

     

       119
        
       };

     

       120
        
       

     

       121
        
       export const never: Source<any> = (sink: Sink<any>): void => {

     
···

       123
        
       };

     

       124
        
       

     

       125
        
       export function interval(ms: number): Source<number> {

     

       126
       +
         return sink => {

     

       127
        
           let i = 0;

     

       128
        
           const id = setInterval(() => {

     

       129
        
             sink(push(i++));

     

       130
        
           }, ms);

     

       131
       +
           sink(

     

       132
       +
             start(signal => {

     

       133
       +
               if (signal === TalkbackKind.Close) clearInterval(id);

     

       134
       +
             })

     

       135
       +
           );

     

       136
        
         };

     

       137
        
       }

     

       138
        
       

     

       139
        
       export function fromDomEvent(element: HTMLElement, event: string): Source<Event> {

     

       140
       +
         return sink => {

     

       141
        
           const handler = (payload: Event) => {

     

       142
        
             sink(push(payload));

     

       143
        
           };

     

       144
       +
           sink(

     

       145
       +
             start(signal => {

     

       146
       +
               if (signal === TalkbackKind.Close) element.removeEventListener(event, handler);

     

       147
       +
             })

     

       148
       +
           );

     

       149
        
           element.addEventListener(event, handler);

     

       150
        
         };

     

       151
        
       }

     

       152
        
       

     

       153
        
       export function fromPromise<T>(promise: Promise<T>): Source<T> {

     

       154
       +
         return sink => {

     

       155
        
           let ended = false;

     

       156
       +
           promise.then(value => {

     

       157
        
             if (!ended) {

     

       158
        
               sink(push(value));

     

       159
        
               sink(SignalKind.End);

     

       160
        
             }

     

       161
        
           });

     

       162
       +
           sink(

     

       163
       +
             start(signal => {

     

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

     

       165
       +
             })

     

       166
       +
           );

     

       167
        
         };

     

       168
        
       }

+3 -3

src/types.ts

···

       13
        
       }

     

       14
        
       

     

       15
        
       export interface Tag<T> {

     

       16
       -
         tag: T

     

       17
        
       }

     

       18
        
       

     

       19
       -
       export type Start<_T> = (Tag<SignalKind.Start> & [TalkbackFn])

     

       20
       -
       export type Push<T> = (Tag<SignalKind.Push> & [T])

     

       21
        
       export type Signal<T> = Start<T> | Push<T> | SignalKind.End;

     

       22
        
       

     

       23
        
       export type Sink<T> = (signal: Signal<T>) => void;

···

       13
        
       }

     

       14
        
       

     

       15
        
       export interface Tag<T> {

     

       16
       +
         tag: T;

     

       17
        
       }

     

       18
        
       

     

       19
       +
       export type Start<_T> = Tag<SignalKind.Start> & [TalkbackFn];

     

       20
       +
       export type Push<T> = Tag<SignalKind.Push> & [T];

     

       21
        
       export type Signal<T> = Start<T> | Push<T> | SignalKind.End;

     

       22
        
       

     

       23
        
       export type Sink<T> = (signal: Signal<T>) => void;