feat(never): no longer export never function

BREAKING CHANGE: no longer exported. Use the `NEVER` constant instead.

spec/exports-spec.ts

@@ -82,10 +82,6 @@ describe('exports', () => {
     expect(merge).to.equal(Rx.Observable.merge);
   });
 
-  it('should have rxjs/observable/never', () => {
-    expect(never).to.equal(Rx.Observable.never);
-  });
-
   it('should have rxjs/observable/of', () => {
     expect(of).to.equal(Rx.Observable.of);
   });

spec/index-spec.ts

@@ -42,6 +42,7 @@ describe('index', () => {
 
   it('should export constants', () => {
     expect(index.EMPTY).to.exist;
+    expect(index.NEVER).to.exist;
   });
 
   it('should export static observable creator functions', () => {
@@ -60,7 +61,6 @@ describe('index', () => {
     expect(index.iif).to.exist;
     expect(index.interval).to.exist;
     expect(index.merge).to.exist;
-    expect(index.never).to.exist;
     expect(index.of).to.exist;
     expect(index.onErrorResumeNext).to.exist;
     expect(index.pairs).to.exist;

spec/observables/fromEvent-spec.ts

@@ -1,6 +1,6 @@
 import { expect } from 'chai';
 import { expectObservable } from '../helpers/marble-testing';
-import { fromEvent, never, timer } from '../../src';
+import { fromEvent, NEVER, timer } from '../../src';
 import { TestScheduler } from '../../src/testing';
 
 declare function asDiagram(arg: string): Function;
@@ -15,7 +15,7 @@ describe('fromEvent', () => {
         timer(50, 20, rxTestScheduler)
           .mapTo('ev')
           .take(2)
-          .concat(never())
+          .concat(NEVER)
           .subscribe(listener);
       },
       removeEventListener: () => void 0,

spec/observables/fromEventPattern-spec.ts

@@ -2,7 +2,7 @@ import { expect } from 'chai';
 import * as sinon from 'sinon';
 import { expectObservable } from '../helpers/marble-testing';
 
-import { fromEventPattern, noop, never, timer } from '../../src';
+import { fromEventPattern, noop, NEVER, timer } from '../../src';
 import { TestScheduler } from '../../src/testing';
 
 declare function asDiagram(arg: string): Function;
@@ -16,7 +16,7 @@ describe('fromEventPattern', () => {
       timer(50, 20, rxTestScheduler)
         .mapTo('ev')
         .take(2)
-        .concat(never())
+        .concat(NEVER)
         .subscribe(h);
     }
     const e1 = fromEventPattern(addHandler);

spec/observables/interval-spec.ts

@@ -1,7 +1,7 @@
 import { expect } from 'chai';
 import * as sinon from 'sinon';
 import { expectObservable } from '../helpers/marble-testing';
-import { asapScheduler, Observable, animationFrameScheduler, queueScheduler } from '../../src';
+import { NEVER, asapScheduler, Observable, animationFrameScheduler, queueScheduler } from '../../src';
 import { TestScheduler } from '../../src/testing';
 import { interval } from '../../src/';
 
@@ -13,7 +13,7 @@ describe('interval', () => {
   asDiagram('interval(1000)')('should create an observable emitting periodically', () => {
     const e1 = interval(20, rxTestScheduler)
       .take(6) // make it actually finite, so it can be rendered
-      .concat(Observable.never()); // but pretend it's infinite by not completing
+      .concat(NEVER); // but pretend it's infinite by not completing
     const expected = '--a-b-c-d-e-f-';
     const values = {
       a: 0,

spec/observables/never-spec.ts

@@ -1,18 +1,18 @@
-import { never } from '../../src/';
+import { NEVER } from '../../src/';
 import { expect } from 'chai';
 import { expectObservable } from '../helpers/marble-testing';
 
 declare const asDiagram: any;
 
-/** @test {never} */
-describe('never', () => {
-  asDiagram('never')('should create a cold observable that never emits', () => {
+/** @test {NEVER} */
+describe('NEVER', () => {
+  asDiagram('NEVER')('should create a cold observable that never emits', () => {
     const expected = '-';
-    const e1 = never();
+    const e1 = NEVER;
     expectObservable(e1).toBe(expected);
   });
 
   it('should return the same instance every time', () => {
-    expect(never()).to.equal(never());
+    expect(NEVER).to.equal(NEVER);
   });
 });

spec/observables/timer-spec.ts

@@ -1,5 +1,5 @@
 import { cold, expectObservable, time } from '../helpers/marble-testing';
-import { timer, never, merge } from '../../src/';
+import { timer, NEVER, merge } from '../../src/';
 import { TestScheduler } from '../../src/testing';
 import { mergeMap } from '../../src/operators';
 
@@ -11,7 +11,7 @@ describe('timer', () => {
   asDiagram('timer(3000, 1000)')('should create an observable emitting periodically', () => {
     const e1 = timer(60, 20, rxTestScheduler)
       .take(4) // make it actually finite, so it can be rendered
-      .concat(never()); // but pretend it's infinite by not completing
+      .concat(NEVER); // but pretend it's infinite by not completing
     const expected = '------a-b-c-d-';
     const values = {
       a: 0,

spec/operators/buffer-spec.ts

@@ -1,10 +1,9 @@
-import * as Rx from '../../src/Rx';
 import { hot, expectObservable, expectSubscriptions } from '../helpers/marble-testing';
+import { buffer, mergeMap, take } from '../../src/operators';
+import { EMPTY, NEVER, throwError, of } from '../../src';
 
 declare function asDiagram(arg: string): Function;
 
-const Observable = Rx.Observable;
-
 /** @test {buffer} */
 describe('Observable.prototype.buffer', () => {
   asDiagram('buffer')('should emit buffers that close and reopen', () => {
@@ -16,77 +15,77 @@ describe('Observable.prototype.buffer', () => {
       y: ['d', 'e', 'f'],
       z: ['g', 'h', 'i']
     };
-    expectObservable(a.buffer(b)).toBe(expected, expectedValues);
+    expectObservable(a.pipe(buffer(b))).toBe(expected, expectedValues);
   });
 
   it('should work with empty and empty selector', () => {
-    const a = Observable.empty();
-    const b = Observable.empty();
+    const a = EMPTY;
+    const b = EMPTY;
     const expected = '|';
-    expectObservable(a.buffer(b)).toBe(expected);
+    expectObservable(a.pipe(buffer(b))).toBe(expected);
   });
 
   it('should work with empty and non-empty selector', () => {
-    const a = Observable.empty();
+    const a = EMPTY;
     const b = hot('-----a-----');
     const expected = '|';
-    expectObservable(a.buffer(b)).toBe(expected);
+    expectObservable(a.pipe(buffer(b))).toBe(expected);
   });
 
   it('should work with non-empty and empty selector', () => {
     const a = hot('--1--2--^--3--4--5---6----7--8--9---0---|');
-    const b = Observable.empty();
+    const b = EMPTY;
     const expected = '|';
-    expectObservable(a.buffer(b)).toBe(expected);
+    expectObservable(a.pipe(buffer(b))).toBe(expected);
   });
 
   it('should work with never and never selector', () => {
-    const a = Observable.never();
-    const b = Observable.never();
+    const a = NEVER;
+    const b = NEVER;
     const expected = '-';
-    expectObservable(a.buffer(b)).toBe(expected);
+    expectObservable(a.pipe(buffer(b))).toBe(expected);
   });
 
   it('should work with never and empty selector', () => {
-    const a = Observable.never();
-    const b = Observable.empty();
+    const a = NEVER;
+    const b = EMPTY;
     const expected = '|';
-    expectObservable(a.buffer(b)).toBe(expected);
+    expectObservable(a.pipe(buffer(b))).toBe(expected);
   });
 
   it('should work with empty and never selector', () => {
-    const a = Observable.empty();
-    const b = Observable.never();
+    const a = EMPTY;
+    const b = NEVER;
     const expected = '|';
-    expectObservable(a.buffer(b)).toBe(expected);
+    expectObservable(a.pipe(buffer(b))).toBe(expected);
   });
 
   it('should work with non-empty and throw selector', () => {
     const a = hot('---^--a--');
-    const b = Observable.throw(new Error('too bad'));
+    const b = throwError(new Error('too bad'));
     const expected = '#';
-    expectObservable(a.buffer(b)).toBe(expected, null, new Error('too bad'));
+    expectObservable(a.pipe(buffer(b))).toBe(expected, null, new Error('too bad'));
   });
 
   it('should work with throw and non-empty selector', () => {
-    const a = Observable.throw(new Error('too bad'));
+    const a = throwError(new Error('too bad'));
     const b = hot('---^--a--');
     const expected = '#';
-    expectObservable(a.buffer(b)).toBe(expected, null, new Error('too bad'));
+    expectObservable(a.pipe(buffer(b))).toBe(expected, null, new Error('too bad'));
   });
 
   it('should work with error', () => {
     const a = hot('---^-------#', null, new Error('too bad'));
     const b = hot('---^--------');
     const expected = '--------#';
-    expectObservable(a.buffer(b)).toBe(expected, null, new Error('too bad'));
+    expectObservable(a.pipe(buffer(b))).toBe(expected, null, new Error('too bad'));
   });
 
   it('should work with error and non-empty selector', () => {
     const a = hot('---^-------#', null, new Error('too bad'));
     const b = hot('---^---a----');
     const expected = '----a---#';
-    expectObservable(a.buffer(b)).toBe(expected, { a: [] }, new Error('too bad'));
+    expectObservable(a.pipe(buffer(b))).toBe(expected, { a: [] }, new Error('too bad'));
   });
 
   it('should work with selector', () => {
@@ -98,11 +97,11 @@ describe('Observable.prototype.buffer', () => {
       a: ['3'],
       b: ['4', '5'],
       c: ['6'],
-      d: [],
+      d: [] as string[],
       e: ['7', '8', '9'],
       f: ['0']
     };
-    expectObservable(a.buffer(b)).toBe(expected, expectedValues);
+    expectObservable(a.pipe(buffer(b))).toBe(expected, expectedValues);
   });
 
   it('should work with selector completed', () => {
@@ -115,9 +114,9 @@ describe('Observable.prototype.buffer', () => {
       a: ['3'],
       b: ['4', '5'],
       c: ['6'],
-      d: []
+      d: [] as string[]
     };
-    expectObservable(a.buffer(b)).toBe(expected, expectedValues);
+    expectObservable(a.pipe(buffer(b))).toBe(expected, expectedValues);
     expectSubscriptions(a.subscriptions).toBe(subs);
   });
 
@@ -131,7 +130,7 @@ describe('Observable.prototype.buffer', () => {
       a: ['3'],
       b: ['4', '5']
     };
-    expectObservable(a.buffer(b), unsub).toBe(expected, expectedValues);
+    expectObservable(a.pipe(buffer(b)), unsub).toBe(expected, expectedValues);
     expectSubscriptions(a.subscriptions).toBe(subs);
   });
 
@@ -146,10 +145,11 @@ describe('Observable.prototype.buffer', () => {
       b: ['4', '5']
     };
 
-    const result = a
-      .mergeMap((x: any) => Observable.of(x))
-      .buffer(b)
-      .mergeMap((x: any) => Observable.of(x));
+    const result = a.pipe(
+      mergeMap((x: any) => of(x)),
+      buffer(b),
+      mergeMap((x: any) => of(x)),
+    );
 
     expectObservable(result, unsub).toBe(expected, expectedValues);
     expectSubscriptions(a.subscriptions).toBe(subs);
@@ -163,17 +163,17 @@ describe('Observable.prototype.buffer', () => {
     const expected =      '---a--b--#';
     const expectedValues = {
       a: [3],
-      b: []
+      b: [] as string[]
     };
-    expectObservable(a.buffer(b)).toBe(expected, expectedValues, new Error('too bad'));
+    expectObservable(a.pipe(buffer(b))).toBe(expected, expectedValues, new Error('too bad'));
     expectSubscriptions(a.subscriptions).toBe(subs);
   });
 
   it('should work with non-empty and empty selector error', () => {
     const a = hot('--1--2--^--3--4--5---6----7--8--9---0---|');
     const b = hot('--------^----------------#', null, new Error('too bad'));
     const expected =      '-----------------#';
-    expectObservable(a.buffer(b)).toBe(expected, null, new Error('too bad'));
+    expectObservable(a.pipe(buffer(b))).toBe(expected, null, new Error('too bad'));
   });
 
   it('should work with non-empty and selector error', () => {
@@ -188,7 +188,7 @@ describe('Observable.prototype.buffer', () => {
       b: ['4', '5'],
       c: ['6']
     };
-    expectObservable(a.buffer(b)).toBe(expected, expectedValues, new Error('too bad'));
+    expectObservable(a.pipe(buffer(b))).toBe(expected, expectedValues, new Error('too bad'));
     expectSubscriptions(a.subscriptions).toBe(subs);
   });
 
@@ -204,7 +204,7 @@ describe('Observable.prototype.buffer', () => {
       b: ['4', '5']
     };
 
-    expectObservable(a.buffer(b), unsub).toBe(expected, expectedValues);
+    expectObservable(a.pipe(buffer(b)), unsub).toBe(expected, expectedValues);
     expectSubscriptions(a.subscriptions).toBe(subs);
     expectSubscriptions(b.subscriptions).toBe(bsubs);
   });
@@ -218,7 +218,7 @@ describe('Observable.prototype.buffer', () => {
       x: ['a', 'b', 'c'],
     };
 
-    expectObservable(a.buffer(b).take(1)).toBe(expected, expectedValues);
+    expectObservable(a.pipe(buffer(b), take(1))).toBe(expected, expectedValues);
     expectSubscriptions(b.subscriptions).toBe(bsubs);
   });
 });

spec/operators/catch-spec.ts

@@ -233,7 +233,7 @@ describe('Observable.prototype.catch', () => {
     expectSubscriptions(e2.subscriptions).toBe(e2subs);
   });
 
-  it('should never terminate if you return Observable.never()', () => {
+  it('should never terminate if you return NEVER', () => {
     const e1 =   hot('--a--b--#');
     const e1subs =   '^       !';
     const e2 = cold(         '-');

spec/operators/debounce-spec.ts

@@ -1,6 +1,7 @@
 import { expect } from 'chai';
 import * as Rx from '../../src/Rx';
 import { hot, cold, expectObservable, expectSubscriptions } from '../helpers/marble-testing';
+import { NEVER } from '../../src/internal/observable/never';
 
 declare const type;
 declare function asDiagram(arg: string): Function;
@@ -316,7 +317,7 @@ describe('Observable.prototype.debounce', () => {
     const e1subs =   '^                                   !';
     const expected = '------------------------------------(z|)';
 
-    function selectorFunction(x) { return Observable.never<number>(); }
+    function selectorFunction() { return NEVER; }
 
     expectObservable(e1.debounce(selectorFunction)).toBe(expected);
     expectSubscriptions(e1.subscriptions).toBe(e1subs);