Fix Iterator.zip and Iterator.zipKeyed behavior with mode: 'longest' option (#1469)

Author: lionel-rowe

packages/core-js/internals/iterator-zip.js

@@ -79,8 +79,8 @@ var IteratorProxy = createIteratorProxy(function () {
         iters[i] = null;
         result = padding[i];
       }
+      push(results, result);
     }
-    push(results, result);
   }
 
   return finishResults ? finishResults(results) : results;

tests/unit-global/esnext.iterator.zip-keyed.js

@@ -1,6 +1,10 @@
 import { createIterator } from '../helpers/helpers.js';
 import { DESCRIPTORS } from '../helpers/constants.js';
 
+function nullProto(obj) {
+  return Object.assign(Object.create(null), obj);
+}
+
 QUnit.test('Iterator.zipKeyed', assert => {
   const { zipKeyed } = Iterator;
   const { from } = Array;
@@ -56,4 +60,41 @@ QUnit.test('Iterator.zipKeyed', assert => {
     assert.same(result[2][bar], 6);
     assert.same(result[2].baz, 9);
   }
+
+  {
+    const result = zipKeyed({
+      a: [0, 1, 2],
+      b: [3, 4, 5, 6, 7],
+      c: [8, 9],
+    }, {
+      mode: "longest",
+    });
+
+    assert.deepEqual(from(result), [
+      nullProto({ a: 0, b: 3, c: 8 }),
+      nullProto({ a: 1, b: 4, c: 9 }),
+      nullProto({ a: 2, b: 5, c: undefined }),
+      nullProto({ a: undefined, b: 6, c: undefined }),
+      nullProto({ a: undefined, b: 7, c: undefined }),
+    ]);
+  }
+
+  {
+    const result = zipKeyed({
+      a: [0, 1, 2],
+      b: [3, 4, 5, 6, 7],
+      c: [8, 9],
+    }, {
+      mode: "longest",
+      padding: { a: 'A', b: 'B', c: 'C' },
+    });
+
+    assert.deepEqual(from(result), [
+      nullProto({ a: 0, b: 3, c: 8 }),
+      nullProto({ a: 1, b: 4, c: 9 }),
+      nullProto({ a: 2, b: 5, c: 'C' }),
+      nullProto({ a: 'A', b: 6, c: 'C' }),
+      nullProto({ a: 'A', b: 7, c: 'C' }),
+    ]);
+  }
 });

tests/unit-global/esnext.iterator.zip.js

@@ -62,4 +62,41 @@ QUnit.test('Iterator.zip', assert => {
     assert.throws(() => from(result), Error);
     assert.true(it2.called, 'iterator return called #4');
   }
+
+  {
+    const result = zip([
+      [0, 1, 2],
+      [3, 4, 5, 6, 7],
+      [8, 9],
+    ], {
+      mode: "longest",
+    });
+
+    assert.deepEqual(from(result), [
+      [0, 3, 8],
+      [1, 4, 9],
+      [2, 5, undefined],
+      [undefined, 6, undefined],
+      [undefined, 7, undefined]
+    ]);
+  }
+
+  {
+    const result = zip([
+      [0, 1, 2],
+      [3, 4, 5, 6, 7],
+      [8, 9],
+    ], {
+      mode: "longest",
+      padding: ["A", "B", "C"],
+    });
+
+    assert.deepEqual(from(result), [
+      [0, 3, 8],
+      [1, 4, 9],
+      [2, 5, 'C'],
+      ['A', 6, 'C'],
+      ['A', 7, 'C']
+    ]);
+  }
 });

tests/unit-pure/esnext.iterator.zip-keyed.js

@@ -6,6 +6,10 @@ import from from 'core-js-pure/es/array/from';
 import Symbol from 'core-js-pure/full/symbol';
 import zipKeyed from 'core-js-pure/full/iterator/zip-keyed';
 
+function nullProto(obj) {
+  return Object.assign(Object.create(null), obj);
+}
+
 QUnit.test('Iterator.zipKeyed', assert => {
   assert.isFunction(zipKeyed);
   assert.arity(zipKeyed, 1);
@@ -55,4 +59,41 @@ QUnit.test('Iterator.zipKeyed', assert => {
     assert.same(result[2][bar], 6);
     assert.same(result[2].baz, 9);
   }
+
+  {
+    const result = zipKeyed({
+      a: [0, 1, 2],
+      b: [3, 4, 5, 6, 7],
+      c: [8, 9],
+    }, {
+      mode: "longest",
+    });
+
+    assert.deepEqual(from(result), [
+      nullProto({ a: 0, b: 3, c: 8 }),
+      nullProto({ a: 1, b: 4, c: 9 }),
+      nullProto({ a: 2, b: 5, c: undefined }),
+      nullProto({ a: undefined, b: 6, c: undefined }),
+      nullProto({ a: undefined, b: 7, c: undefined }),
+    ]);
+  }
+
+  {
+    const result = zipKeyed({
+      a: [0, 1, 2],
+      b: [3, 4, 5, 6, 7],
+      c: [8, 9],
+    }, {
+      mode: "longest",
+      padding: { a: 'A', b: 'B', c: 'C' },
+    });
+
+    assert.deepEqual(from(result), [
+      nullProto({ a: 0, b: 3, c: 8 }),
+      nullProto({ a: 1, b: 4, c: 9 }),
+      nullProto({ a: 2, b: 5, c: 'C' }),
+      nullProto({ a: 'A', b: 6, c: 'C' }),
+      nullProto({ a: 'A', b: 7, c: 'C' }),
+    ]);
+  }
 });

tests/unit-pure/esnext.iterator.zip.js

@@ -60,4 +60,41 @@ QUnit.test('Iterator.zip', assert => {
     assert.throws(() => from(result), Error);
     assert.true(it2.called, 'iterator return called #4');
   }
+
+  {
+    const result = zip([
+      [0, 1, 2],
+      [3, 4, 5, 6, 7],
+      [8, 9],
+    ], {
+      mode: "longest",
+    });
+
+    assert.deepEqual(from(result), [
+      [0, 3, 8],
+      [1, 4, 9],
+      [2, 5, undefined],
+      [undefined, 6, undefined],
+      [undefined, 7, undefined]
+    ]);
+  }
+
+  {
+    const result = zip([
+      [0, 1, 2],
+      [3, 4, 5, 6, 7],
+      [8, 9],
+    ], {
+      mode: "longest",
+      padding: ["A", "B", "C"],
+    });
+
+    assert.deepEqual(from(result), [
+      [0, 3, 8],
+      [1, 4, 9],
+      [2, 5, 'C'],
+      ['A', 6, 'C'],
+      ['A', 7, 'C']
+    ]);
+  }
 });