Make isArrayLike check more precise to avoid false positives (immutable-js#1520)

acusti · leebyron · commit b29b484669a6 · 2018-05-17T14:57:59.000Z
* Update isArrayLike check to be more precise

Verify that a value is array-like by checking for
a numeric length and by confirming that it has the
length - 1 key set (even if it is undefined). If
length is 0, then check that it doesn’t have any
other properties other than length

* Array-likes may also have additional non-numeric keys

* Handle length === 0 edge case

* Ensure integer lengths

* Format
diff --git a/__tests__/List.ts b/__tests__/List.ts
@@ -58,9 +58,9 @@ describe('List', () => {
   });
 
   it('accepts an array-like', () => {
-    const v = List({ length: 3, 1: 'b' } as any);
-    expect(v.get(1)).toBe('b');
-    expect(v.toArray()).toEqual([undefined, 'b', undefined]);
+    const v = List({ length: 3, 2: 'c' } as any);
+    expect(v.get(2)).toBe('c');
+    expect(v.toArray()).toEqual([undefined, undefined, 'c']);
   });
 
   it('accepts any array-like collection, including strings', () => {
diff --git a/__tests__/Seq.ts b/__tests__/Seq.ts
@@ -47,11 +47,19 @@ describe('Seq', () => {
   });
 
   it('accepts an array-like', () => {
-    const alike: any = { length: 2, 0: 'a', 1: 'b' };
-    const seq = Seq(alike);
+    const seq = Seq({ length: 2, 0: 'a', 1: 'b' });
     expect(isIndexed(seq)).toBe(true);
     expect(seq.size).toBe(2);
     expect(seq.get(1)).toBe('b');
+
+    const map = Seq({ length: 1, foo: 'bar' });
+    expect(isIndexed(map)).toBe(false);
+    expect(map.size).toBe(2);
+    expect(map.get('foo')).toBe('bar');
+
+    const empty = Seq({ length: 0 });
+    expect(isIndexed(empty)).toBe(true);
+    expect(empty.size).toEqual(0);
   });
 
   it('does not accept a scalar', () => {
diff --git a/__tests__/Set.ts b/__tests__/Set.ts
@@ -20,11 +20,11 @@ describe('Set', () => {
   });
 
   it('accepts array-like of values', () => {
-    const s = Set<any>({ length: 3, 1: 2 } as any);
+    const s = Set<any>({ length: 3, 2: 3 } as any);
     expect(s.size).toBe(2);
     expect(s.has(undefined)).toBe(true);
-    expect(s.has(2)).toBe(true);
-    expect(s.has(1)).toBe(false);
+    expect(s.has(3)).toBe(true);
+    expect(s.has(2)).toBe(false);
   });
 
   it('accepts string, an array-like collection', () => {
diff --git a/src/utils/isArrayLike.js b/src/utils/isArrayLike.js
@@ -6,5 +6,20 @@
  */
 
 export default function isArrayLike(value) {
-  return value && typeof value.length === 'number';
+  if (Array.isArray(value) || typeof value === 'string') {
+    return true;
+  }
+
+  return (
+    value &&
+    typeof value === 'object' &&
+    Number.isInteger(value.length) &&
+    value.length >= 0 &&
+    (value.length === 0
+      ? // Only {length: 0} is considered Array-like.
+        Object.keys(value).length === 1
+      : // An object is only Array-like if it has a property where the last value
+        // in the array-like may be found (which could be undefined).
+        value.hasOwnProperty(value.length - 1))
+  );
 }
