immutable 4.0.0-rc.14 → 4.0.0-rc.15

package/dist/immutable.es.js

@@ -244,6 +244,11 @@ function iteratorDone() {
 }
 
 function hasIterator(maybeIterable) {
+  if (Array.isArray(maybeIterable)) {
+    // IE11 trick as it does not support `Symbol.iterator`
+    return true;
+  }
+
   return !!getIteratorFn(maybeIterable);
 }
 
@@ -266,6 +271,16 @@ function getIteratorFn(iterable) {
   }
 }
 
+function isEntriesIterable(maybeIterable) {
+  var iteratorFn = getIteratorFn(maybeIterable);
+  return iteratorFn && iteratorFn === maybeIterable.entries;
+}
+
+function isKeysIterable(maybeIterable) {
+  var iteratorFn = getIteratorFn(maybeIterable);
+  return iteratorFn && iteratorFn === maybeIterable.keys;
+}
+
 var hasOwnProperty = Object.prototype.hasOwnProperty;
 
 function isArrayLike(value) {
@@ -596,11 +611,7 @@ function emptySequence() {
 }
 
 function keyedSeqFromValue(value) {
-  var seq = Array.isArray(value)
-    ? new ArraySeq(value)
-    : hasIterator(value)
-    ? new CollectionSeq(value)
-    : undefined;
+  var seq = maybeIndexedSeqFromValue(value);
   if (seq) {
     return seq.fromEntrySeq();
   }
@@ -626,7 +637,11 @@ function indexedSeqFromValue(value) {
 function seqFromValue(value) {
   var seq = maybeIndexedSeqFromValue(value);
   if (seq) {
-    return seq;
+    return isEntriesIterable(value)
+      ? seq.fromEntrySeq()
+      : isKeysIterable(value)
+      ? seq.toSetSeq()
+      : seq;
   }
   if (typeof value === 'object') {
     return new ObjectSeq(value);
@@ -2271,7 +2286,9 @@ function mergeWithSources(collection, sources, merger) {
 
 function deepMergerWith(merger) {
   function deepMerger(oldValue, newValue, key) {
-    return isDataStructure(oldValue) && isDataStructure(newValue)
+    return isDataStructure(oldValue) &&
+      isDataStructure(newValue) &&
+      areMergeable(oldValue, newValue)
       ? mergeWithSources(oldValue, [newValue], deepMerger)
       : merger
       ? merger(oldValue, newValue, key)
@@ -2280,6 +2297,22 @@ function deepMergerWith(merger) {
   return deepMerger;
 }
 
+/**
+ * It's unclear what the desired behavior is for merging two collections that
+ * fall into separate categories between keyed, indexed, or set-like, so we only
+ * consider them mergeable if they fall into the same category.
+ */
+function areMergeable(oldDataStructure, newDataStructure) {
+  var oldSeq = Seq(oldDataStructure);
+  var newSeq = Seq(newDataStructure);
+  // This logic assumes that a sequence can only fall into one of the three
+  // categories mentioned above (since there's no `isSetLike()` method).
+  return (
+    isIndexed(oldSeq) === isIndexed(newSeq) &&
+    isKeyed(oldSeq) === isKeyed(newSeq)
+  );
+}
+
 function mergeDeep() {
   var iters = [], len = arguments.length;
   while ( len-- ) iters[ len ] = arguments[ len ];
@@ -5295,14 +5328,16 @@ mixin(SetCollection, {
   },
 });
 
-SetCollection.prototype.has = CollectionPrototype.includes;
-SetCollection.prototype.contains = SetCollection.prototype.includes;
+var SetCollectionPrototype = SetCollection.prototype;
+SetCollectionPrototype.has = CollectionPrototype.includes;
+SetCollectionPrototype.contains = SetCollectionPrototype.includes;
+SetCollectionPrototype.keys = SetCollectionPrototype.values;
 
 // Mixin subclasses
 
-mixin(KeyedSeq, KeyedCollection.prototype);
-mixin(IndexedSeq, IndexedCollection.prototype);
-mixin(SetSeq, SetCollection.prototype);
+mixin(KeyedSeq, KeyedCollectionPrototype);
+mixin(IndexedSeq, IndexedCollectionPrototype);
+mixin(SetSeq, SetCollectionPrototype);
 
 // #pragma Helper functions
 
@@ -5799,12 +5834,11 @@ function fromJS(value, converter) {
 }
 
 function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
-  var toSeq = Array.isArray(value)
-    ? IndexedSeq
-    : isPlainObject(value)
-    ? KeyedSeq
-    : null;
-  if (toSeq) {
+  if (
+    typeof value !== 'string' &&
+    !isImmutable(value) &&
+    (isArrayLike(value) || hasIterator(value) || isPlainObject(value))
+  ) {
     if (~stack.indexOf(value)) {
       throw new TypeError('Cannot convert circular structure to Immutable');
     }
@@ -5813,7 +5847,7 @@ function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
     var converted = converter.call(
       parentValue,
       key,
-      toSeq(value).map(function (v, k) { return fromJSWith(stack, converter, v, k, keyPath, value); }
+      Seq(value).map(function (v, k) { return fromJSWith(stack, converter, v, k, keyPath, value); }
       ),
       keyPath && keyPath.slice()
     );
@@ -5825,10 +5859,11 @@ function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
 }
 
 function defaultConverter(k, v) {
-  return isKeyed(v) ? v.toMap() : v.toList();
+  // Effectively the opposite of "Collection.toSeq()"
+  return isIndexed(v) ? v.toList() : isKeyed(v) ? v.toMap() : v.toSet();
 }
 
-var version = "4.0.0-rc.14";
+var version = "4.0.0-rc.15";
 
 var Immutable = {
   version: version,

package/dist/immutable.js

@@ -250,6 +250,11 @@
   }
 
   function hasIterator(maybeIterable) {
+    if (Array.isArray(maybeIterable)) {
+      // IE11 trick as it does not support `Symbol.iterator`
+      return true;
+    }
+
     return !!getIteratorFn(maybeIterable);
   }
 
@@ -272,6 +277,16 @@
     }
   }
 
+  function isEntriesIterable(maybeIterable) {
+    var iteratorFn = getIteratorFn(maybeIterable);
+    return iteratorFn && iteratorFn === maybeIterable.entries;
+  }
+
+  function isKeysIterable(maybeIterable) {
+    var iteratorFn = getIteratorFn(maybeIterable);
+    return iteratorFn && iteratorFn === maybeIterable.keys;
+  }
+
   var hasOwnProperty = Object.prototype.hasOwnProperty;
 
   function isArrayLike(value) {
@@ -602,11 +617,7 @@
   }
 
   function keyedSeqFromValue(value) {
-    var seq = Array.isArray(value)
-      ? new ArraySeq(value)
-      : hasIterator(value)
-      ? new CollectionSeq(value)
-      : undefined;
+    var seq = maybeIndexedSeqFromValue(value);
     if (seq) {
       return seq.fromEntrySeq();
     }
@@ -632,7 +643,11 @@
   function seqFromValue(value) {
     var seq = maybeIndexedSeqFromValue(value);
     if (seq) {
-      return seq;
+      return isEntriesIterable(value)
+        ? seq.fromEntrySeq()
+        : isKeysIterable(value)
+        ? seq.toSetSeq()
+        : seq;
     }
     if (typeof value === 'object') {
       return new ObjectSeq(value);
@@ -2277,7 +2292,9 @@
 
   function deepMergerWith(merger) {
     function deepMerger(oldValue, newValue, key) {
-      return isDataStructure(oldValue) && isDataStructure(newValue)
+      return isDataStructure(oldValue) &&
+        isDataStructure(newValue) &&
+        areMergeable(oldValue, newValue)
         ? mergeWithSources(oldValue, [newValue], deepMerger)
         : merger
         ? merger(oldValue, newValue, key)
@@ -2286,6 +2303,22 @@
     return deepMerger;
   }
 
+  /**
+   * It's unclear what the desired behavior is for merging two collections that
+   * fall into separate categories between keyed, indexed, or set-like, so we only
+   * consider them mergeable if they fall into the same category.
+   */
+  function areMergeable(oldDataStructure, newDataStructure) {
+    var oldSeq = Seq(oldDataStructure);
+    var newSeq = Seq(newDataStructure);
+    // This logic assumes that a sequence can only fall into one of the three
+    // categories mentioned above (since there's no `isSetLike()` method).
+    return (
+      isIndexed(oldSeq) === isIndexed(newSeq) &&
+      isKeyed(oldSeq) === isKeyed(newSeq)
+    );
+  }
+
   function mergeDeep() {
     var iters = [], len = arguments.length;
     while ( len-- ) iters[ len ] = arguments[ len ];
@@ -5301,14 +5334,16 @@
     },
   });
 
-  SetCollection.prototype.has = CollectionPrototype.includes;
-  SetCollection.prototype.contains = SetCollection.prototype.includes;
+  var SetCollectionPrototype = SetCollection.prototype;
+  SetCollectionPrototype.has = CollectionPrototype.includes;
+  SetCollectionPrototype.contains = SetCollectionPrototype.includes;
+  SetCollectionPrototype.keys = SetCollectionPrototype.values;
 
   // Mixin subclasses
 
-  mixin(KeyedSeq, KeyedCollection.prototype);
-  mixin(IndexedSeq, IndexedCollection.prototype);
-  mixin(SetSeq, SetCollection.prototype);
+  mixin(KeyedSeq, KeyedCollectionPrototype);
+  mixin(IndexedSeq, IndexedCollectionPrototype);
+  mixin(SetSeq, SetCollectionPrototype);
 
   // #pragma Helper functions
 
@@ -5805,12 +5840,11 @@
   }
 
   function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
-    var toSeq = Array.isArray(value)
-      ? IndexedSeq
-      : isPlainObject(value)
-      ? KeyedSeq
-      : null;
-    if (toSeq) {
+    if (
+      typeof value !== 'string' &&
+      !isImmutable(value) &&
+      (isArrayLike(value) || hasIterator(value) || isPlainObject(value))
+    ) {
       if (~stack.indexOf(value)) {
         throw new TypeError('Cannot convert circular structure to Immutable');
       }
@@ -5819,7 +5853,7 @@
       var converted = converter.call(
         parentValue,
         key,
-        toSeq(value).map(function (v, k) { return fromJSWith(stack, converter, v, k, keyPath, value); }
+        Seq(value).map(function (v, k) { return fromJSWith(stack, converter, v, k, keyPath, value); }
         ),
         keyPath && keyPath.slice()
       );
@@ -5831,10 +5865,11 @@
   }
 
   function defaultConverter(k, v) {
-    return isKeyed(v) ? v.toMap() : v.toList();
+    // Effectively the opposite of "Collection.toSeq()"
+    return isIndexed(v) ? v.toList() : isKeyed(v) ? v.toMap() : v.toSet();
   }
 
-  var version = "4.0.0-rc.14";
+  var version = "4.0.0-rc.15";
 
   var Immutable = {
     version: version,

package/dist/immutable.js.flow

@@ -25,11 +25,14 @@
 // some constructors and functions.
 type PlainObjInput<K, V> = { +[key: K]: V, __proto__: null };
 
+type K<T> = $Keys<T>;
+
 // Helper types to extract the "keys" and "values" use by the *In() methods.
 type $KeyOf<C> = $Call<
   (<K>(?_Collection<K, mixed>) => K) &
     (<T>(?$ReadOnlyArray<T>) => number) &
-    (<T>(?RecordInstance<T> | T) => $Keys<T>),
+    (<T>(?RecordInstance<T> | T) => $Keys<T>) &
+    (<T: Object>(T) => $Keys<T>),
   C
 >;
 
@@ -37,7 +40,7 @@ type $ValOf<C, K = $KeyOf<C>> = $Call<
   (<V>(?_Collection<any, V>) => V) &
     (<T>(?$ReadOnlyArray<T>) => T) &
     (<T, K: $Keys<T>>(?RecordInstance<T> | T, K) => $ElementType<T, K>) &
-    (<V>(?{ [any]: V }) => V),
+    (<T: Object>(T) => $Values<T>),
   C,
   K
 >;
@@ -593,7 +596,8 @@ declare class KeyedSeq<K, +V> extends Seq<K, V> mixins KeyedCollection<K, V> {
 
 declare class IndexedSeq<+T>
   extends Seq<number, T>
-  mixins IndexedCollection<T> {
+  mixins IndexedCollection<T>
+{
   static <T>(values?: Iterable<T>): IndexedSeq<T>;
 
   static of<T>(...values: T[]): IndexedSeq<T>;
@@ -892,7 +896,8 @@ declare function isList(maybeList: mixed): boolean %checks(maybeList instanceof
   List);
 declare class List<+T>
   extends IndexedCollection<T>
-  mixins UpdatableInCollection<number, T> {
+  mixins UpdatableInCollection<number, T>
+{
   static (collection?: Iterable<T>): List<T>;
 
   static of<T>(...values: T[]): List<T>;
@@ -1050,7 +1055,8 @@ declare function isMap(maybeMap: mixed): boolean %checks(maybeMap instanceof
   Map);
 declare class Map<K, +V>
   extends KeyedCollection<K, V>
-  mixins UpdatableInCollection<K, V> {
+  mixins UpdatableInCollection<K, V>
+{
   static <K, V>(values?: Iterable<[K, V]> | PlainObjInput<K, V>): Map<K, V>;
 
   static isMap: typeof isMap;
@@ -1147,7 +1153,8 @@ declare function isOrderedMap(
 ): boolean %checks(maybeOrderedMap instanceof OrderedMap);
 declare class OrderedMap<K, +V>
   extends Map<K, V>
-  mixins UpdatableInCollection<K, V> {
+  mixins UpdatableInCollection<K, V>
+{
   static <K, V>(
     values?: Iterable<[K, V]> | PlainObjInput<K, V>
   ): OrderedMap<K, V>;
@@ -1905,7 +1912,7 @@ declare function fromJS(
     sequence: KeyedCollection<string, mixed> | IndexedCollection<mixed>,
     path?: Array<string | number>
   ) => mixed
-): mixed;
+): Collection<mixed, mixed>;
 
 declare function is(first: mixed, second: mixed): boolean;
 declare function hash(value: mixed): number;