You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
155 lines
4.4 KiB
JavaScript
155 lines
4.4 KiB
JavaScript
'use strict';
|
|
var ctx = require('./_ctx')
|
|
, $export = require('./_export')
|
|
, createDesc = require('./_property-desc')
|
|
, assign = require('./_object-assign')
|
|
, create = require('./_object-create')
|
|
, getPrototypeOf = require('./_object-gpo')
|
|
, getKeys = require('./_object-keys')
|
|
, dP = require('./_object-dp')
|
|
, keyOf = require('./_keyof')
|
|
, aFunction = require('./_a-function')
|
|
, forOf = require('./_for-of')
|
|
, isIterable = require('./core.is-iterable')
|
|
, $iterCreate = require('./_iter-create')
|
|
, step = require('./_iter-step')
|
|
, isObject = require('./_is-object')
|
|
, toIObject = require('./_to-iobject')
|
|
, DESCRIPTORS = require('./_descriptors')
|
|
, has = require('./_has');
|
|
|
|
// 0 -> Dict.forEach
|
|
// 1 -> Dict.map
|
|
// 2 -> Dict.filter
|
|
// 3 -> Dict.some
|
|
// 4 -> Dict.every
|
|
// 5 -> Dict.find
|
|
// 6 -> Dict.findKey
|
|
// 7 -> Dict.mapPairs
|
|
var createDictMethod = function(TYPE){
|
|
var IS_MAP = TYPE == 1
|
|
, IS_EVERY = TYPE == 4;
|
|
return function(object, callbackfn, that /* = undefined */){
|
|
var f = ctx(callbackfn, that, 3)
|
|
, O = toIObject(object)
|
|
, result = IS_MAP || TYPE == 7 || TYPE == 2
|
|
? new (typeof this == 'function' ? this : Dict) : undefined
|
|
, key, val, res;
|
|
for(key in O)if(has(O, key)){
|
|
val = O[key];
|
|
res = f(val, key, object);
|
|
if(TYPE){
|
|
if(IS_MAP)result[key] = res; // map
|
|
else if(res)switch(TYPE){
|
|
case 2: result[key] = val; break; // filter
|
|
case 3: return true; // some
|
|
case 5: return val; // find
|
|
case 6: return key; // findKey
|
|
case 7: result[res[0]] = res[1]; // mapPairs
|
|
} else if(IS_EVERY)return false; // every
|
|
}
|
|
}
|
|
return TYPE == 3 || IS_EVERY ? IS_EVERY : result;
|
|
};
|
|
};
|
|
var findKey = createDictMethod(6);
|
|
|
|
var createDictIter = function(kind){
|
|
return function(it){
|
|
return new DictIterator(it, kind);
|
|
};
|
|
};
|
|
var DictIterator = function(iterated, kind){
|
|
this._t = toIObject(iterated); // target
|
|
this._a = getKeys(iterated); // keys
|
|
this._i = 0; // next index
|
|
this._k = kind; // kind
|
|
};
|
|
$iterCreate(DictIterator, 'Dict', function(){
|
|
var that = this
|
|
, O = that._t
|
|
, keys = that._a
|
|
, kind = that._k
|
|
, key;
|
|
do {
|
|
if(that._i >= keys.length){
|
|
that._t = undefined;
|
|
return step(1);
|
|
}
|
|
} while(!has(O, key = keys[that._i++]));
|
|
if(kind == 'keys' )return step(0, key);
|
|
if(kind == 'values')return step(0, O[key]);
|
|
return step(0, [key, O[key]]);
|
|
});
|
|
|
|
function Dict(iterable){
|
|
var dict = create(null);
|
|
if(iterable != undefined){
|
|
if(isIterable(iterable)){
|
|
forOf(iterable, true, function(key, value){
|
|
dict[key] = value;
|
|
});
|
|
} else assign(dict, iterable);
|
|
}
|
|
return dict;
|
|
}
|
|
Dict.prototype = null;
|
|
|
|
function reduce(object, mapfn, init){
|
|
aFunction(mapfn);
|
|
var O = toIObject(object)
|
|
, keys = getKeys(O)
|
|
, length = keys.length
|
|
, i = 0
|
|
, memo, key;
|
|
if(arguments.length < 3){
|
|
if(!length)throw TypeError('Reduce of empty object with no initial value');
|
|
memo = O[keys[i++]];
|
|
} else memo = Object(init);
|
|
while(length > i)if(has(O, key = keys[i++])){
|
|
memo = mapfn(memo, O[key], key, object);
|
|
}
|
|
return memo;
|
|
}
|
|
|
|
function includes(object, el){
|
|
return (el == el ? keyOf(object, el) : findKey(object, function(it){
|
|
return it != it;
|
|
})) !== undefined;
|
|
}
|
|
|
|
function get(object, key){
|
|
if(has(object, key))return object[key];
|
|
}
|
|
function set(object, key, value){
|
|
if(DESCRIPTORS && key in Object)dP.f(object, key, createDesc(0, value));
|
|
else object[key] = value;
|
|
return object;
|
|
}
|
|
|
|
function isDict(it){
|
|
return isObject(it) && getPrototypeOf(it) === Dict.prototype;
|
|
}
|
|
|
|
$export($export.G + $export.F, {Dict: Dict});
|
|
|
|
$export($export.S, 'Dict', {
|
|
keys: createDictIter('keys'),
|
|
values: createDictIter('values'),
|
|
entries: createDictIter('entries'),
|
|
forEach: createDictMethod(0),
|
|
map: createDictMethod(1),
|
|
filter: createDictMethod(2),
|
|
some: createDictMethod(3),
|
|
every: createDictMethod(4),
|
|
find: createDictMethod(5),
|
|
findKey: findKey,
|
|
mapPairs: createDictMethod(7),
|
|
reduce: reduce,
|
|
keyOf: keyOf,
|
|
includes: includes,
|
|
has: has,
|
|
get: get,
|
|
set: set,
|
|
isDict: isDict
|
|
}); |