This app provides monitoring and information features for the common freifunk user and the technical stuff of a freifunk community.
Code base is taken from a TUM Practical Course project and added here to see if Freifunk Altdorf can use it.
https://www.freifunk-altdorf.de
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.
153 lines
4.3 KiB
153 lines
4.3 KiB
'use strict'; |
|
var $ = require('./$') |
|
, ctx = require('./$.ctx') |
|
, $export = require('./$.export') |
|
, createDesc = require('./$.property-desc') |
|
, assign = require('./$.object-assign') |
|
, 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') |
|
, getKeys = $.getKeys; |
|
|
|
// 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)$.setDesc(object, key, createDesc(0, value)); |
|
else object[key] = value; |
|
return object; |
|
} |
|
|
|
function isDict(it){ |
|
return isObject(it) && $.getProto(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 |
|
}); |