added defaultArrayIfEmpty() method

Author: mkloubert

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change Log (node-enumerable)
 
+## 3.6.0 (November 5th, 2017; methods)
+
+* added `defaultArrayIfEmpty()` method
+
 ## 3.5.2 (November 5th, 2017; methods)
 
 * added `cos()` and `arcCos()` methods

README.md

@@ -36,7 +36,7 @@
      * [chunk](#chunk-)
      * [clone](#clone-)
      * [concat / concatArray](#concat--concatarray-)
-     * [defaultIfEmpty / defaultSequenceIfEmpty](#defaultifempty--defaultsequenceifempty-)
+     * [defaultIfEmpty / defaultArrayIfEmpty / defaultSequenceIfEmpty](#defaultifempty--defaultarrayifempty--defaultsequenceifempty-)
      * [intersperse / intersperseArray](#intersperse--interspersearray-)
      * [popFrom / shiftFrom](#popfrom--shiftfrom-)
      * [pushTo](#pushto-)
@@ -684,7 +684,7 @@ Enumerable.create(0, 0.5, -1)
 
 ### More [[↑](#examples-)]
 
-#### Chunk [[↑](#more-)]
+#### chunk [[↑](#more-)]
 
 ```javascript
 let seq = Enumerable.range(0, 10);
@@ -721,7 +721,7 @@ Enumerable.create(0, 111, 222)
           .concatArray([ [ 'pz', 'tm' ], [ 'mk' ] ]);
 ```
 
-#### defaultIfEmpty / defaultSequenceIfEmpty [[↑](#more-)]
+#### defaultIfEmpty / defaultArrayIfEmpty / defaultSequenceIfEmpty [[↑](#more-)]
 
 ```javascript
 // 0, 1, 2
@@ -735,6 +735,7 @@ Enumerable.create()
 // 0, 11, 22
 Enumerable.create(0, 11, 22)
           .defaultSequenceIfEmpty(['pz', 'tm', 'mk']);
+// alt: defaultArrayIfEmpty()
 
 // 'pz', 'tm', 'mk'
 Enumerable.create()

demo/js/enumerable.js

@@ -436,6 +436,10 @@ declare namespace Enumerable {
          * Gets the current iterator result.
          */
         readonly current: IteratorResult<T>;
+        /**
+         * Alias for defaultSequenceIfEmpty()
+         */
+        defaultArrayIfEmpty(defaultSequence: Sequence<T>): IEnumerable<T>;
         /**
          * Returns the items of that sequence or a default item list
          * if that sequence is empty.
@@ -1169,6 +1173,8 @@ declare namespace Enumerable {
         /** @inheritdoc */
         readonly current: IteratorResult<T>;
         /** @inheritdoc */
+        defaultArrayIfEmpty(defaultSequence: Sequence<T>): IEnumerable<T>;
+        /** @inheritdoc */
         defaultIfEmpty(...defaultItems: Array<T>): IEnumerable<T>;
         /**
          * @see defaultIfEmpty()

index.d.ts

@@ -479,6 +479,10 @@ namespace Enumerable {
          * Gets the current iterator result.
          */
         readonly current: IteratorResult<T>;
+        /**
+         * Alias for defaultSequenceIfEmpty()
+         */
+        defaultArrayIfEmpty(defaultSequence: Sequence<T>): IEnumerable<T>;
         /**
          * Returns the items of that sequence or a default item list
          * if that sequence is empty.
@@ -1598,6 +1602,11 @@ namespace Enumerable {
             return this._current;
         }
         /** @inheritdoc */
+        public defaultArrayIfEmpty(defaultSequence: Sequence<T>): IEnumerable<T> {
+            return this.defaultSequenceIfEmpty
+                       .apply(this, arguments);
+        }
+        /** @inheritdoc */
         public defaultIfEmpty(...defaultItems: Array<T>): IEnumerable<T> {
             return from(this.defaultIfEmptyInner(defaultItems));
         }

index.ts

@@ -0,0 +1,76 @@
+// The MIT License (MIT)
+// 
+// node-enumerable (https://github.com/mkloubert/node-enumerable)
+// Copyright (c) Marcel Joachim Kloubert <marcel.kloubert@gmx.net>
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+import Assert = require('assert');
+import Enumerable = require('../../');
+import Helpers = require('../helpers');
+
+const MAX_ARRAY_SIZE = 100;
+
+Helpers.execute(
+    'Testing numbers...',
+    (ctx) => {
+        for (let i = 0; i < MAX_ARRAY_SIZE; i++) {
+            if (0 === i % 10) {
+                ctx.log(`Testing with ${i} elements...`);
+            }
+
+            // fill test array
+            let arr: any[] = [];
+            for (let j = 0; j < i; j++) {
+                arr.push(j);
+            }
+
+            let e = Enumerable.from(arr)
+                              .defaultArrayIfEmpty([ 'MK', 'TM', 'JS', 'YS' ]);
+
+            let testArr: any[] = [];
+            while (!e.next().done) {
+                testArr.push(e.current.value);
+            }
+
+            let expected: any[];
+            if (arr.length > 0) {
+                expected = arr;
+            }
+            else {
+                expected = ['MK', 'TM', 'JS', 'YS'];
+            }
+
+            Assert.strictEqual(testArr.length, expected.length);
+            Assert.equal(testArr.length, expected.length);
+            Assert.equal('' + testArr.length, expected.length);
+            Assert.equal(testArr.length, '' + expected.length);
+            Assert.equal('' + testArr.length, '' + expected.length);
+            Assert.strictEqual('' + testArr.length, '' + expected.length);
+
+            for (let j = 0; j < testArr.length; j++) {
+                Assert.strictEqual(testArr[j], expected[j]);
+                Assert.equal(testArr[j], expected[j]);
+                Assert.equal('' + testArr[j], expected[j]);
+                Assert.equal(testArr[j], '' + expected[j]);
+                Assert.equal('' + testArr[j], '' + expected[j]);
+                Assert.strictEqual('' + testArr[j], '' + expected[j]);
+            }
+        }
+    });