@angular/http
Version:
Angular - the http service
346 lines • 11.3 kB
JavaScript
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { getSymbolIterator, isArray, isBlank, isJsObject, isPresent } from './lang';
// Safari and Internet Explorer do not support the iterable parameter to the
// Map constructor. We work around that by manually adding the items.
var createMapFromPairs = (function () {
try {
if (new Map([[1, 2]]).size === 1) {
return function createMapFromPairs(pairs) { return new Map(pairs); };
}
}
catch (e) {
}
return function createMapAndPopulateFromPairs(pairs) {
var map = new Map();
for (var i = 0; i < pairs.length; i++) {
var pair = pairs[i];
map.set(pair[0], pair[1]);
}
return map;
};
})();
var createMapFromMap = (function () {
try {
if (new Map(new Map())) {
return function createMapFromMap(m) { return new Map(m); };
}
}
catch (e) {
}
return function createMapAndPopulateFromMap(m) {
var map = new Map();
m.forEach(function (v, k) { map.set(k, v); });
return map;
};
})();
var _clearValues = (function () {
if ((new Map()).keys().next) {
return function _clearValues(m) {
var keyIterator = m.keys();
var k;
while (!((k = keyIterator.next()).done)) {
m.set(k.value, null);
}
};
}
else {
return function _clearValuesWithForeEach(m) {
m.forEach(function (v, k) { m.set(k, null); });
};
}
})();
// Safari doesn't implement MapIterator.next(), which is used is Traceur's polyfill of Array.from
// TODO(mlaval): remove the work around once we have a working polyfill of Array.from
var _arrayFromMap = (function () {
try {
if ((new Map()).values().next) {
return function createArrayFromMap(m, getValues) {
return getValues ? Array.from(m.values()) : Array.from(m.keys());
};
}
}
catch (e) {
}
return function createArrayFromMapWithForeach(m, getValues) {
var res = new Array(m.size), i = 0;
m.forEach(function (v, k) {
res[i] = getValues ? v : k;
i++;
});
return res;
};
})();
export var MapWrapper = (function () {
function MapWrapper() {
}
MapWrapper.createFromStringMap = function (stringMap) {
var result = new Map();
for (var prop in stringMap) {
result.set(prop, stringMap[prop]);
}
return result;
};
MapWrapper.toStringMap = function (m) {
var r = {};
m.forEach(function (v, k) { return r[k] = v; });
return r;
};
MapWrapper.createFromPairs = function (pairs) { return createMapFromPairs(pairs); };
MapWrapper.iterable = function (m) { return m; };
MapWrapper.keys = function (m) { return _arrayFromMap(m, false); };
MapWrapper.values = function (m) { return _arrayFromMap(m, true); };
return MapWrapper;
}());
/**
* Wraps Javascript Objects
*/
export var StringMapWrapper = (function () {
function StringMapWrapper() {
}
StringMapWrapper.get = function (map, key) {
return map.hasOwnProperty(key) ? map[key] : undefined;
};
StringMapWrapper.set = function (map, key, value) { map[key] = value; };
StringMapWrapper.keys = function (map) { return Object.keys(map); };
StringMapWrapper.values = function (map) {
return Object.keys(map).map(function (k) { return map[k]; });
};
StringMapWrapper.isEmpty = function (map) {
for (var prop in map) {
return false;
}
return true;
};
StringMapWrapper.forEach = function (map, callback) {
for (var _i = 0, _a = Object.keys(map); _i < _a.length; _i++) {
var k = _a[_i];
callback(map[k], k);
}
};
StringMapWrapper.merge = function (m1, m2) {
var m = {};
for (var _i = 0, _a = Object.keys(m1); _i < _a.length; _i++) {
var k = _a[_i];
m[k] = m1[k];
}
for (var _b = 0, _c = Object.keys(m2); _b < _c.length; _b++) {
var k = _c[_b];
m[k] = m2[k];
}
return m;
};
StringMapWrapper.equals = function (m1, m2) {
var k1 = Object.keys(m1);
var k2 = Object.keys(m2);
if (k1.length != k2.length) {
return false;
}
for (var i = 0; i < k1.length; i++) {
var key = k1[i];
if (m1[key] !== m2[key]) {
return false;
}
}
return true;
};
return StringMapWrapper;
}());
export var ListWrapper = (function () {
function ListWrapper() {
}
// JS has no way to express a statically fixed size list, but dart does so we
// keep both methods.
ListWrapper.createFixedSize = function (size) { return new Array(size); };
ListWrapper.createGrowableSize = function (size) { return new Array(size); };
ListWrapper.clone = function (array) { return array.slice(0); };
ListWrapper.forEachWithIndex = function (array, fn) {
for (var i = 0; i < array.length; i++) {
fn(array[i], i);
}
};
ListWrapper.first = function (array) {
if (!array)
return null;
return array[0];
};
ListWrapper.last = function (array) {
if (!array || array.length == 0)
return null;
return array[array.length - 1];
};
ListWrapper.indexOf = function (array, value, startIndex) {
if (startIndex === void 0) { startIndex = 0; }
return array.indexOf(value, startIndex);
};
ListWrapper.contains = function (list, el) { return list.indexOf(el) !== -1; };
ListWrapper.reversed = function (array) {
var a = ListWrapper.clone(array);
return a.reverse();
};
ListWrapper.concat = function (a, b) { return a.concat(b); };
ListWrapper.insert = function (list, index, value) { list.splice(index, 0, value); };
ListWrapper.removeAt = function (list, index) {
var res = list[index];
list.splice(index, 1);
return res;
};
ListWrapper.removeAll = function (list, items) {
for (var i = 0; i < items.length; ++i) {
var index = list.indexOf(items[i]);
list.splice(index, 1);
}
};
ListWrapper.remove = function (list, el) {
var index = list.indexOf(el);
if (index > -1) {
list.splice(index, 1);
return true;
}
return false;
};
ListWrapper.clear = function (list) { list.length = 0; };
ListWrapper.isEmpty = function (list) { return list.length == 0; };
ListWrapper.fill = function (list, value, start, end) {
if (start === void 0) { start = 0; }
if (end === void 0) { end = null; }
list.fill(value, start, end === null ? list.length : end);
};
ListWrapper.equals = function (a, b) {
if (a.length != b.length)
return false;
for (var i = 0; i < a.length; ++i) {
if (a[i] !== b[i])
return false;
}
return true;
};
ListWrapper.slice = function (l, from, to) {
if (from === void 0) { from = 0; }
if (to === void 0) { to = null; }
return l.slice(from, to === null ? undefined : to);
};
ListWrapper.splice = function (l, from, length) { return l.splice(from, length); };
ListWrapper.sort = function (l, compareFn) {
if (isPresent(compareFn)) {
l.sort(compareFn);
}
else {
l.sort();
}
};
ListWrapper.toString = function (l) { return l.toString(); };
ListWrapper.toJSON = function (l) { return JSON.stringify(l); };
ListWrapper.maximum = function (list, predicate) {
if (list.length == 0) {
return null;
}
var solution = null;
var maxValue = -Infinity;
for (var index = 0; index < list.length; index++) {
var candidate = list[index];
if (isBlank(candidate)) {
continue;
}
var candidateValue = predicate(candidate);
if (candidateValue > maxValue) {
solution = candidate;
maxValue = candidateValue;
}
}
return solution;
};
ListWrapper.flatten = function (list) {
var target = [];
_flattenArray(list, target);
return target;
};
ListWrapper.addAll = function (list, source) {
for (var i = 0; i < source.length; i++) {
list.push(source[i]);
}
};
return ListWrapper;
}());
function _flattenArray(source, target) {
if (isPresent(source)) {
for (var i = 0; i < source.length; i++) {
var item = source[i];
if (isArray(item)) {
_flattenArray(item, target);
}
else {
target.push(item);
}
}
}
return target;
}
export function isListLikeIterable(obj) {
if (!isJsObject(obj))
return false;
return isArray(obj) ||
(!(obj instanceof Map) &&
getSymbolIterator() in obj); // JS Iterable have a Symbol.iterator prop
}
export function areIterablesEqual(a, b, comparator) {
var iterator1 = a[getSymbolIterator()]();
var iterator2 = b[getSymbolIterator()]();
while (true) {
var item1 = iterator1.next();
var item2 = iterator2.next();
if (item1.done && item2.done)
return true;
if (item1.done || item2.done)
return false;
if (!comparator(item1.value, item2.value))
return false;
}
}
export function iterateListLike(obj, fn) {
if (isArray(obj)) {
for (var i = 0; i < obj.length; i++) {
fn(obj[i]);
}
}
else {
var iterator = obj[getSymbolIterator()]();
var item;
while (!((item = iterator.next()).done)) {
fn(item.value);
}
}
}
// Safari and Internet Explorer do not support the iterable parameter to the
// Set constructor. We work around that by manually adding the items.
var createSetFromList = (function () {
var test = new Set([1, 2, 3]);
if (test.size === 3) {
return function createSetFromList(lst) { return new Set(lst); };
}
else {
return function createSetAndPopulateFromList(lst) {
var res = new Set(lst);
if (res.size !== lst.length) {
for (var i = 0; i < lst.length; i++) {
res.add(lst[i]);
}
}
return res;
};
}
})();
export var SetWrapper = (function () {
function SetWrapper() {
}
SetWrapper.createFromList = function (lst) { return createSetFromList(lst); };
SetWrapper.has = function (s, key) { return s.has(key); };
SetWrapper.delete = function (m, k) { m.delete(k); };
return SetWrapper;
}());
//# sourceMappingURL=collection.js.map