feat(never): no longer export never function

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

@@ -50,6 +50,7 @@ describe('index', () => {
 
  it('should export constants', () => {
  expect(index.EMPTY).to.exist;
+ expect(index.NEVER).to.exist;
  });
 
  it('should export static observable creator functions', () => {
@@ -67,7 +68,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/internal/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/internal/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);