es6-map-shim.js

/**
 * Copyright 2012 Eric Wendelin - MIT License
 *
 * es6-map-shim.js is a DESTRUCTIVE shim that follows the latest Map specification
 * as closely as possible. It is destructive in the sense that it overrides native implementations.
 *
 * IMPORTANT: Currently, get(), set(), has() and delete() are all O(n) operations.
 * Normally, they would be O(1). Therefore it is NOT recommended to use this with
 * a large dataset or in any production environment.
 *
 * This library assumes ES5 functionality: Object.create, Object.defineProperty,
 * Array.indexOf, Function.bind and others.
 */
(function(module) {
    function Map(iterable) {
        var _items = [];
        var _keys = [];
        var _values = [];

        // Object.is polyfill, courtesy of @WebReflection
        var is = Object.is || function(a, b) {
            return a === b ?
                a !== 0 || 1 / a == 1 / b :
                a != a && b != b;
        };

        // More reliable indexOf, courtesy of @WebReflection
        var betterIndexOf = function(value) {
            if(value != value || value === 0) {
                for(var i = this.length; i-- && !is(this[i], value););
            } else {
                i = [].indexOf.call(this, value);
            }
            return i;
        };

        /**
         * MapIterator used for iterating over all entries in given map.
         *
         * @param map {Map} to iterate
         * @param kind {String} identifying what to yield. Possible values
         *      are 'keys', 'values' and 'keys+values'
         * @constructor
         */
        var MapIterator = function MapIterator(map, kind) {
            var _index = 0;

            return Object.create({}, {
                next: {
                    value: function() {
                        // check if index is within bounds
                        if (_index < map.items().length) {
                            switch(kind) {
                                case 'keys': return map.keys()[_index++];
                                case 'values': return map.values()[_index++];
                                case 'keys+values': return [].slice.call(map.items()[_index++]);
                                default: throw new TypeError('Invalid iterator type');
                            }
                        }
                        // TODO: make sure I'm interpreting the spec correctly here
                        throw new Error('Stop Iteration');
                    }
                },
                iterator: {
                    value: function() {
                        return this;
                    }
                },
                toString: {
                    value: function() {
                        return '[object Map Iterator]';
                    }
                }
            });
        };

        var _set = function(key, value) {
            // check if key exists and overwrite
            var index = betterIndexOf.call(_keys, key);
            if (index > -1) {
                _items[index][1] = value;
                _values[index] = value;
            } else {
                _items.push([key, value]);
                _keys.push(key);
                _values.push(value);
            }
        };

        var setItem = function(item) {
            if (item.length !== 2) {
                throw new TypeError('Invalid iterable passed to Map constructor');
            }

            _set(item[0], item[1]);
        };

        // FIXME: accommodate any class that defines an @@iterator method that returns
        //      an iterator object that produces two element array-like objects
        if (Array.isArray(iterable)) {
            iterable.forEach(setItem);
        } else if (iterable !== undefined) {
            throw new TypeError('Invalid Map');
        }

        return Object.create(MapPrototype, {
            /**
             * @return {Array} all entries in the Map, in order
             */
            items:{
                value:function() {
                    return [].slice.call(_items);
                }
            },
            /**
             * @return {Array} all keys in the Map, in order
             */
            keys:{
                value:function() {
                    return [].slice.call(_keys);
                }
            },
            /**
             * @return {Array} all values in the Map, in order
             */
            values:{
                value:function() {
                    return [].slice.call(_values);
                }
            },
            /**
             * Given a key, indicate whether that key exists in this Map.
             *
             * @param key {Object} expected key
             * @return {Boolean} true if key in Map
             */
            has:{
                value:function(key) {
                    // TODO: double-check how spec reads about null values
                    var index = betterIndexOf.call(_keys, key);
                    return index > -1;
                }
            },
            /**
             * Given a key, retrieve the value associated with that key (or undefined).
             *
             * @param key {Object}
             * @return {Object} value associated with key or undefined
             */
            get:{
                value:function(key) {
                    var index = betterIndexOf.call(_keys, key);
                    return index > -1 ? _values[index] : undefined;
                }
            },
            /**
             * Add or overwrite entry associating key with value. Always returns undefined.
             *
             * @param key {Object} anything
             * @param value {Object} also anything
             */
            set:{
                value: _set
            },
            /**
             * Return the number of entries in this Map.
             *
             * @return {Number} number of entries
             */
            size:{
                get:function() {
                    return _items.length;
                }
            },
            /**
             * Remove all entries in this Map. Returns undefined.
             */
            clear:{
                value:function() {
                    _keys.length = _values.length = _items.length = 0;
                }
            },
            /**
             * Delete entry with given key, if it exists.
             *
             * @param key {Object} any possible key
             * @return {Boolean} true if an entry was deleted
             */
            'delete':{
                value:function(key) {
                    var index = betterIndexOf.call(_keys, key);
                    if (index > -1) {
                        _keys.splice(index, 1);
                        _values.splice(index, 1);
                        _items.splice(index, 1);
                        return true;
                    }
                    return false;
                }
            },
            /**
             * Given a callback function and optional context, invoke the callback on all
             * entries in this Map.
             *
             * @param callbackFn {Function}
             */
            forEach:{
                value:function(callbackfn /*, thisArg*/) {
                    if (typeof callbackfn != 'function') {
                        throw new TypeError('Invalid callback function given to forEach');
                    }

                    function tryNext() {
                        try {
                            return iter.next();
                        } catch(e) {
                            return undefined;
                        }
                    }

                    var iter = this.iterator();
                    var current = tryNext();
                    var next = tryNext();
                    while(current !== undefined) {
                        callbackfn.apply(arguments[1], [current[1], current[0], this]);
                        current = next;
                        next = tryNext();
                    }
                }
            },
            /**
             * Return a MapIterator object for this map.
             */
            iterator:{
                value: function() {
                    return new MapIterator(this, 'keys+values');
                }
            },
            toString:{
                value: function() {
                    return '[Object Map]';
                }
            }
        });
    }

    var notInNode = module == 'undefined';
    var window = notInNode ? this : global;
    var module = notInNode ? {} : exports;
    var MapPrototype = Map.prototype;

    Map.prototype = MapPrototype = Map();

    window.Map = module.Map = window.Map || Map;
}.call(this, typeof exports));