Add static onErrorResumeNext()

src/Enumerable.ts

@@ -1,4 +1,3 @@
 import { Enumerable } from './internal/Enumerable';
 
 export default Enumerable;
-

src/extensions/static/onErrorResumeNext.ts

@@ -0,0 +1,14 @@
+import onErrorResumeNextFn from '../../static/onErrorResumeNext';
+import { Enumerable } from '../../internal/Enumerable';
+
+function onErrorResumeNext<TSource>(...sources: Iterable<TSource>[]): Enumerable<TSource> {
+    return new Enumerable(onErrorResumeNextFn(...sources));
+}
+
+Enumerable.onErrorResumeNext = onErrorResumeNext;
+
+declare module '../../internal/Enumerable' {
+    namespace Enumerable {
+        export function onErrorResumeNext<TSource>(...sources: Iterable<TSource>[]): Enumerable<TSource>;
+    }
+}

src/index.ts

@@ -53,6 +53,7 @@ import './extensions/static/concat';
 import './extensions/static/defer';
 import './extensions/static/generate';
 import './extensions/static/if';
+import './extensions/static/onErrorResumeNext';
 import './extensions/static/range';
 import './extensions/static/repeat';
 import './extensions/static/return';

src/onErrorResumeNext.ts

@@ -3,5 +3,8 @@ export default function* onErrorResumeNext<TSource>(this: Iterable<TSource>, sec
         yield* this;
     } catch (error) {
     }
-    yield* second;
+    try {
+        yield* second;
+    } catch (error) {
+    }
 }

src/static/onErrorResumeNext.ts

@@ -0,0 +1,8 @@
+export default function* onErrorResumeNext<TSource>(...sources: Iterable<TSource>[]) {
+    for (const source of sources) {
+        try {
+            yield* source;
+        } catch (error) {
+        }
+    }
+}

test/onErrorResumeNextTest.ts

@@ -10,7 +10,13 @@ describe('onErrorResumeNext()', () => {
                 throw new Error()
             }
         };
-        const ys = [3, 4];
+        const ys = {
+            [Symbol.iterator]: function*() {
+                yield 3
+                yield 4
+                throw new Error()
+            }
+        };
         assert.deepEqual(new Enumerable(xs).onErrorResumeNext(ys).toArray(), [1, 2, 3, 4]);
     });
 });

test/static/onErrorResumeNext.ts

@@ -0,0 +1,23 @@
+import * as assert from 'assert';
+import Enumerable from '../../src/';
+
+describe('onErrorResumeNext()', () => {
+    it('should creates a sequence that concatenates both given sequences', () => {
+        const xs = {
+            [Symbol.iterator]: function*() {
+                yield 1;
+                yield 2;
+                throw new Error();
+            }
+        };
+        const ys = {
+            [Symbol.iterator]: function*() {
+                yield 3;
+                yield 4;
+                throw new Error();
+            }
+        };
+        assert.deepEqual(Enumerable.onErrorResumeNext(xs, ys).toArray(), [1, 2, 3, 4]);
+    });
+});
+