immutable

New:

• contains() is now called includes() to match the ES6 specification. contains() still exists as an alias.

New:

• merge() family of functions now get the currently merging key as a 3rd argument, in case merge strategy should alter based on key.
• IndexedCursor now has push(), pop(), unshift() and shift() to more closely mirror List.
• Records initialize lazily. Creating a new Record type with Record({foo:"bar"}) involves a small bit of work. For applications with a large amount of Records, lazy initialization should help startup times.
• Maps can now be constructed by a List of Lists instead of only a List of Arrays.
• toString() prints Map string keys in quotes.

Fixes:

• is() allows usage of valueOf to return primitives without recursing or encountering a reference error.
• merge()/union() work inside withMutations when initial collection is empty. #405
• Producing subcursors using cursor.cursor() now returns a proper typed cursor. #381
• When a Record is passed to the same Record creation function, it's now returned directly.
• Ensure Records toString() correctly. #383
• Iterating over a sliced Seq can no longer cause an infinite recursion. #394
• Ensure we don't throw when hashing non-extensible object in a modern environment.
• Fix issue where non-existent function could be called if a collection doesn't have a size.

Fixes:

• 3.6.3 was a broken npm release.

Fixes:

• Improve test coverage of Stack, fixing #332 and #353
• Numerous typo fixings. Me spel gud.
• Fix collection toString() when an ES6 Symbol is a value in the collection.
• Consider a prototype-free object a "plain object". Fixes #302
• No long enumerates extra key in canDefineProperty in rare cases in some versions of Chrome

Fixes:

• Improves performance of creating Cursors.

Fixes:

• Iterating over a Cursor to a List could result in an infinite loop.

New:

• findEntry() and findLastEntry() will return [key, value] tuples of the first value to pass a predicate. Related to find() and findLast() which only return value.
• contrib/Cursor now has the wider suite of methods found on List and Map including:
  • updateIn()
  • setIn()
  • deleteIn()
  • merge()
  • mergeWith()
  • mergeIn()
  • mergeDeep()
  • mergeDeepWith()
  • mergeDeepIn()

Fixes:

• UMD module wrapper safer to use with CommonJS -> AMD bundlers.
• Clarified some examples in documentation

New:

• zip(), zipWith() and interleave() for combining multiple collections are new methods on indexed collections.
• isEmpty() is safer than comparing count() or size to 0.
• groupBy() now returns OrderedMap when called on an ordered collection.
• hashCode() included in public API

Fixes:

• Custom toJSON() methods on values in a collection respected when provided to JSON.stringify().
• Fixed issue with browserify including Cursor.
• Throws TypeError if getIn/updateIn/hasIn/etc. are not provided valid key paths.

Fixes:

• deleteIn alias now exists for all types (was missing from Map).
• Improve min/max to be order-independent when handling null/undefined/NaN

New:

• Improved documentation in Immutable.d.ts, resulting in better generated documentation.
• remove and removeIn are now alises for the methods delete and deleteIn. No effect on execution (but deleteIn is new).
• Added deleteIn on Record.
• Added hasIn - deeply query for value existence.
• Cursor onChange function can now intercept the new value and return an override (3598f8c71f54cddba8e09647226e77dce69f6b1e).
• +0 and -0 are treated as the same value in Immutable.is (key equality and Set existence).
• valueOf() is now used when determining value equality between two objects. This allows Date to be used as Map key, and provides a more straight-forward way to implement value equality for custom types.

Fixes:

• Mapping over infinite Seq no longer throws error about Infinite iteration. (Improve accuracy of infinite iteration warning overall).
• Ensure setIn can set undefined as a value.
• List iterators no longer return invalid values if the List was the result of a slice or shift.

New:

• setIn added to Record
• Added mergeIn and deepMergeIn to Map and List.
• updateIn, and all *In methods accept any Iterable as key path, not just Array.
• Optimization for concat, merge and union. If this is empty, and a single non-empty argument is provided, then attempt to return the argument unmodified.

Fixes:

• Documentation improvements
• Tests to ensure equality symmetry and hash equality
• Performance improvements to collection hashing

Fixes

• Ensure equality symmetry

New:

• Immutable.isOrdered describes if an iterable has a defined iteration order.
• Immutable.is and iterable#equals now respect ordered-ness to evaluate equality.

New:

• Performance enhancement to Maps and Sets with 8 or fewer entries.
• OrderedSet introduced.
• Map and Set can now be sorted, returning an OrderedMap or OrderedSet, respectively.
• Improved sortBy, maxBy and minBy performance

Fixed:

• Map#set or Set#add now return themselves for a no-op involving a hash collision.
• Accessing an Indexed Iterable (such as List) with strings are now coerced to number when possible, mirroring the behavior of native Array.
• List, Stack and Set constructors documentation now matches behavior.
• Records now ignore unknown keys provided to constructors.
• OrderedMap no longer leaks memory when keys are removed.

A number of issues with v3.0.0 spotted and fixed by the growing Immutable.js community.

Fixes:

• Indexed and Set constructors no longer accept Objects, an unintended edge case which led to easy to make mistakes.
• Indexed and Set constructors accept Keyed Iterables as lists of [K,V] entries rather than dropping the keys, better mirroring ES6 Map and Set behavior.
• Collection constructors no longer throw when provided null/undefined and instead return empty collections. Better mirroring the behavior of ES6 Map/Set.
• concat accepts arguments of similar type as it's this's constructor. Ensures objects passed to concat are not exploded into an array of fields which is almost never intended.
• Record equality works as advertised
• Record iteration now includes default fields
• Map iteration no longer incorrectly yield values on ES6 browsers (Chrome canary)
• Implicit any removed from TypeScript files
• OrderedMap no longer breaks when keys are removed.
• Cursor iterators now reference proper this.
• Improvements to example code and Readme.

• mergeDeep is smarter about when to merge nested values vs replacing existing values.
• Mention Record in README

Fixes:

• Cursors in contrib now work in any ES5 environment

v3.0.0 brings the Immutable collection API closer to ES6 Map and Set, introduces opt-in lazy operations, clarifies the differences between keyed and non-keyed collections and more.

A lot has changed, please check out the upgrade guide for more details and help for upgrading your code to work with this new version of the library.

New:

• Collection methods (map, filter, etc) are now eager by default.
• Seq and toSeq for explicit lazy operations.
• Renamed Sequence to Iterable
• Renamed Vector to List
• Renamed length to size
• Constructors now always accept Iterable.
  • empty() and from() removed
  • of(...values) on indexed and set collections
• contrib/ directory
  • Cursor now moved to contrib.
• "is type" predicates exist on all major Iterable types, such as Map.isMap().
• groupBy() and countBy() return concrete Map.
• Added: keyOf() and lastKeyOf() on KeyedIterable are similar to indexOf() and lastIndexOf() on IndexedIterable.

Fixes:

• Vector slicing along N^2-1 bound could result in exception.
• Negative slice could result in a sized collection.
• Many link and url fixes to README.

Fix filename issue on case-sensitive file systems

New:

• max, maxBy, min, minBy - find the largest or smallest item in any sequence.
• filterNot - filters by the complement of the predicate, e.g. where the filter function returns false, the values will be kept.
• setIn and removeIn for altering deep immutable structures.

Fixes:

• Object Hash will no longer be overridden if shared between multiple global contexts.
• Immutable sequences from different requires in the same environment interact correctly for toJS and equals.

Fixes:

• updateIn could fail to set a value if it matched the default value, or if it looked like an empty collection.
• base Sequences no longer have unsafe specialized toArray and toObject functions which could cause accidental mutation of the immutable Sequences.
• hashing uses WeakMap if available, resulting in a best possible case of not touching JS objects used as keys.
• Distribution files are now lowercase.js, matching the package name to aleviate any confusion or case-sensitive file system woes.

New:

• seq.toStack() as alias for Stack(seq)
• flatten now accepts a depth number or shallow boolean to describe how deep it should flatten, by default it now flattens deeply.

Fixed:

• Cursors can now represent Indexed sequences #97
• Readme updates: explain CDN, update examples.
• record.clear() no longer mysteriously vanishes.
• Unsafe get and has optimizations removed from ValuesSeq.
• last on a sequence with unknown length no longer returns undefined #141
• seq.reverse().get(i) no longer returns incorrect values for indexed sequences.
• seq.filter().get(i) no longer returns incorrect values for indexed sequences.
• flatten no longer flattens sequencible values (string, array, object), but only Sequence instances, leading to more predictable flattening.

New:

• Stack! a linked-list style structure with efficient addition and removal from the front of the list.

Fixes:

• indexedSeq.skip(n).get(i) now returns the correct value.
• skip(n).get(-i) and take(n).get(-i) return correct values for negative indices.
• IE8 issue with Record
• Throw when trying to set an invalid key on Record.

Iterators!

All Sequences, including both concrete collections (Map, Vector, Set) and lazy Sequences (mapped, filtered) can be iterated.

API:

values() returns an iterator object where each call to next() provides the next value.

keys() returns an iterator object where each call to next() provides the next key.

entries() returns an iterator object where each call to next() provides the next entry as a [key, value] tuple.

Example:

var myMap = Immutable.Map([['A', 1], ['B', 2], ['C', 3]]);
var entries = myMap.entries();
entries.next() // { value: ['A', 1], done: false }
entries.next() // { value: ['B', 2], done: false }
entries.next() // { value: ['C', 3], done: false }
entries.next() // { value: undefined, done: true }

All Sequences also support iteration via the @@iterator and Symbol.iterator methods, so they can be used in ES6 for-of comprehensions.

New

• interpose()
• Sequence documentation is easier to follow now that methods are categorized and alphabetized.
• A number of lazy sequence optimizations. For example, seq.flip().reverse().flip() becomes seq.reverse().
• Optimizations that allow get() and has() to be O(1) on lazy sequences.

Bugs

• Equality checking via Immutable.is or seq.equals() could throw or incorrectly return false.

Fixed: Immutable.is() could throw for some Sequences

• Improved using arbitrary Objects as keys or as members of a Set for IE8.
• Fixed: collections did not always return correct length iterated from forEach()
• Sequences (and Maps, Vectors, and Sets) can now be constructed from Iterables and Iterators. This enables Map and Set construction similar to ES6 spec.

var m = new Map([['A', 1], ['B', 2], ['C', 3]]);
// Map {"A" => 1, "B" => 2, "C" => 3}
var im = Immutable.Map(m);
// Map { A: 1, B: 2, C: 3 }
m = new Map(im);
// Map {"A" => 1, "B" => 2, "C" => 3}

• Fixed: some Sequences did not properly provide themselves as the 3rd argument in iteration.
• Fixed: take() could iterate one step too far.
• Fixed: getIn() could throw if one of the intermediate keys does not exist.

New:

• groupBy and countBy now return Sequence instead of Map.

Bugs:

• Fix issue where seq.flip().reverse() can result in incorrect value.

New:

• Indexed Sequences are now always treated densely, including Vector and ArraySequence. This means iterators, forEach, and Sequence methods visit unset indices, and has returns true for unset indicies within length. This warrants a minor-version bump.
• flatten turns a Sequence of Sequences into a single Sequence.
• flatMap maps over a Sequence, flattening the result. The alias chain is provided to begin to adhere to the Fantasy Land spec.
• Indexed Sequences can now be accessed by negative indicies, which index from the end of the Sequence.

Bugs:

• ensure 3rd argument in sequence functions is always parent sequence.
• reduce behavior matches Array#reduce.
• join behavior matches Array#join
• Fix type definition error for mergeDeep
• Fix equality checking for Sets.
• Fix issue where Safari/JSC incorrectly JITs hash creation, resulting in "missing values" or exceptions.

New new new!

• Cursor now has withMutations
• We're available on Bower!

Bugs Fixed:

• take and skip now return immutable sequences.
• splice behavior now matches Array.prototype.splice

Breaking Changes:

• Sequence's keys, values, entries and fromEntries renamed to keySeq, valueSeq, entrySeq and fromEntrySeq respectively.

Features Added:

• Sets can now contain Collections and JS Objects
• Maps can now use Collections and JS Objects as keys
• ES6 Iteration methods, keys, values and entries, added to all concrete collections.
• concrete collections can be used directly in ES6 for-of loops
• Vector iterator follows ES6 spec: dense iteration but adds an optional param to get sparse iteration.
• Improved performance of Vector iteration and folding.

Bugs Fixed:

• IE8 no longer complains about "delete" used as a method
• Cursor access and sequence methods now always return Cursors.

• Source used by node is now not-minified
• withMutations and all complex mutation methods implemented with it (such as merge), now return this when they result in a no-op.
• Fixed bug where a Map key could be incorrectly dropped.
• Cursors now behave as Sequences and share more of the Map API
• Clarify API of update and updateIn

• Fix warnings with node v0.10
• Fix issue with case-sensitive file systems
• Significant performance improvements to Map
• Bug fixes:
  • Deleting key from map can result in incorrect result
  • Deleting key from map can result in thrown error
  • Map iteration was returning incorrect value
  • Map key comparison was incorrect for complex keys (e.g. NaN)

• Bugs:
  • TypeScript resolution was occasionally incorrect
  • pop() of 33-element Vector returned incorrect result.
• Additions:
  • Cursor API expanded
  • Map() constructor now mirrors ES6 spec.
  • Vector's Iterator now adheres to ES6 spec.

• Cursors - Alpha support. Please provide feedback!
• rest and butLast methods.
• Jasmine-check tests - Yay robust!
• API Changes:
  • updateIn now creates empty Maps for missing keys, previously it simply performed no update.
• Fixed bugs:
  • Map inserts with colliding hashes was causing a stack overflow.
  • Unshift >32 elements caused structural failure.
  • Slicing a Range could result in incorrect return value.
  • updateIn and getIn with empty array would throw, now it correctly applys the change to the root element.