You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
157 lines
4.4 KiB
157 lines
4.4 KiB
'use strict'; |
|
var ctx = require('./_ctx'); |
|
var $export = require('./_export'); |
|
var createDesc = require('./_property-desc'); |
|
var assign = require('./_object-assign'); |
|
var create = require('./_object-create'); |
|
var getPrototypeOf = require('./_object-gpo'); |
|
var getKeys = require('./_object-keys'); |
|
var dP = require('./_object-dp'); |
|
var keyOf = require('./_keyof'); |
|
var aFunction = require('./_a-function'); |
|
var forOf = require('./_for-of'); |
|
var isIterable = require('./core.is-iterable'); |
|
var $iterCreate = require('./_iter-create'); |
|
var step = require('./_iter-step'); |
|
var isObject = require('./_is-object'); |
|
var toIObject = require('./_to-iobject'); |
|
var DESCRIPTORS = require('./_descriptors'); |
|
var 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; |
|
var IS_EVERY = TYPE == 4; |
|
return function (object, callbackfn, that /* = undefined */) { |
|
var f = ctx(callbackfn, that, 3); |
|
var O = toIObject(object); |
|
var result = IS_MAP || TYPE == 7 || TYPE == 2 |
|
? new (typeof this == 'function' ? this : Dict)() : undefined; |
|
var 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; |
|
var O = that._t; |
|
var keys = that._a; |
|
var kind = that._k; |
|
var 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); |
|
var keys = getKeys(O); |
|
var length = keys.length; |
|
var i = 0; |
|
var 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) { |
|
// eslint-disable-next-line no-self-compare |
|
return (el == el ? keyOf(object, el) : findKey(object, function (it) { |
|
// eslint-disable-next-line no-self-compare |
|
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 |
|
});
|
|
|