feat(throw): implement new static factory throw()

src/Stream.ts

@@ -141,6 +141,13 @@ export class Stream<T> implements InternalListener<T> {
     });
   }
 
+  static ['throw'](err: any): Stream<void> {
+    return new Stream<void>({
+      _start(il: InternalListener<void>) { il._e(err); },
+      _stop: noop,
+    });
+  }
+
   static from<T>(array: Array<T>): Stream<T> {
     return new Stream<T>(new FromProducer(array));
   }

tests/factory/throw.ts

@@ -0,0 +1,18 @@
+import xs from '../../src/index';
+import * as assert from 'assert';
+
+describe('xs.throw()', function() {
+  it('should create a stream with just one error emission', (done) => {
+    const stream = xs.throw(new Error('not nice'));
+
+    stream.addListener({
+      next: () => done(new Error('This should not be called')),
+      error: (err: any) => {
+        assert.strictEqual(err instanceof Error, true);
+        assert.strictEqual(err.message, 'not nice');
+        done();
+      },
+      complete: done,
+    });
+  });
+});

tests/stream.ts

@@ -38,6 +38,7 @@ describe('Stream', () => {
     assert.equal(typeof xs.createWithMemory, 'function');
     assert.equal(typeof xs.never, 'function');
     assert.equal(typeof xs.empty, 'function');
+    assert.equal(typeof xs.throw, 'function');
     assert.equal(typeof xs.from, 'function');
     assert.equal(typeof xs.of, 'function');
     assert.equal(typeof xs.interval, 'function');