@angular/router-deprecated
Version:
386 lines • 11.9 kB
JavaScript
var globalScope;
if (typeof window === 'undefined') {
if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {
// TODO: Replace any with WorkerGlobalScope from lib.webworker.d.ts #3492
globalScope = self;
}
else {
globalScope = global;
}
}
else {
globalScope = window;
}
export function scheduleMicroTask(fn) {
Zone.current.scheduleMicroTask('scheduleMicrotask', fn);
}
export const IS_DART = false;
// Need to declare a new variable for global here since TypeScript
// exports the original value of the symbol.
var _global = globalScope;
export { _global as global };
export var Type = Function;
export function getTypeNameForDebugging(type) {
if (type['name']) {
return type['name'];
}
return typeof type;
}
export var Math = _global.Math;
export var Date = _global.Date;
var _devMode = true;
var _modeLocked = false;
export function lockMode() {
_modeLocked = true;
}
/**
* Disable Angular's development mode, which turns off assertions and other
* checks within the framework.
*
* One important assertion this disables verifies that a change detection pass
* does not result in additional changes to any bindings (also known as
* unidirectional data flow).
* @stable
*/
export function enableProdMode() {
if (_modeLocked) {
// Cannot use BaseException as that ends up importing from facade/lang.
throw 'Cannot enable prod mode after platform setup.';
}
_devMode = false;
}
export function assertionsEnabled() {
return _devMode;
}
// TODO: remove calls to assert in production environment
// Note: Can't just export this and import in in other files
// as `assert` is a reserved keyword in Dart
_global.assert = function assert(condition) {
// TODO: to be fixed properly via #2830, noop for now
};
export function isPresent(obj) {
return obj !== undefined && obj !== null;
}
export function isBlank(obj) {
return obj === undefined || obj === null;
}
export function isBoolean(obj) {
return typeof obj === 'boolean';
}
export function isNumber(obj) {
return typeof obj === 'number';
}
export function isString(obj) {
return typeof obj === 'string';
}
export function isFunction(obj) {
return typeof obj === 'function';
}
export function isType(obj) {
return isFunction(obj);
}
export function isStringMap(obj) {
return typeof obj === 'object' && obj !== null;
}
const STRING_MAP_PROTO = Object.getPrototypeOf({});
export function isStrictStringMap(obj) {
return isStringMap(obj) && Object.getPrototypeOf(obj) === STRING_MAP_PROTO;
}
export function isPromise(obj) {
return obj instanceof _global.Promise;
}
export function isArray(obj) {
return Array.isArray(obj);
}
export function isDate(obj) {
return obj instanceof Date && !isNaN(obj.valueOf());
}
export function noop() { }
export function stringify(token) {
if (typeof token === 'string') {
return token;
}
if (token === undefined || token === null) {
return '' + token;
}
if (token.name) {
return token.name;
}
if (token.overriddenName) {
return token.overriddenName;
}
var res = token.toString();
var newLineIndex = res.indexOf('\n');
return (newLineIndex === -1) ? res : res.substring(0, newLineIndex);
}
// serialize / deserialize enum exist only for consistency with dart API
// enums in typescript don't need to be serialized
export function serializeEnum(val) {
return val;
}
export function deserializeEnum(val, values) {
return val;
}
export function resolveEnumToken(enumValue, val) {
return enumValue[val];
}
export class StringWrapper {
static fromCharCode(code) { return String.fromCharCode(code); }
static charCodeAt(s, index) { return s.charCodeAt(index); }
static split(s, regExp) { return s.split(regExp); }
static equals(s, s2) { return s === s2; }
static stripLeft(s, charVal) {
if (s && s.length) {
var pos = 0;
for (var i = 0; i < s.length; i++) {
if (s[i] != charVal)
break;
pos++;
}
s = s.substring(pos);
}
return s;
}
static stripRight(s, charVal) {
if (s && s.length) {
var pos = s.length;
for (var i = s.length - 1; i >= 0; i--) {
if (s[i] != charVal)
break;
pos--;
}
s = s.substring(0, pos);
}
return s;
}
static replace(s, from, replace) {
return s.replace(from, replace);
}
static replaceAll(s, from, replace) {
return s.replace(from, replace);
}
static slice(s, from = 0, to = null) {
return s.slice(from, to === null ? undefined : to);
}
static replaceAllMapped(s, from, cb) {
return s.replace(from, function (...matches) {
// Remove offset & string from the result array
matches.splice(-2, 2);
// The callback receives match, p1, ..., pn
return cb(matches);
});
}
static contains(s, substr) { return s.indexOf(substr) != -1; }
static compare(a, b) {
if (a < b) {
return -1;
}
else if (a > b) {
return 1;
}
else {
return 0;
}
}
}
export class StringJoiner {
constructor(parts = []) {
this.parts = parts;
}
add(part) { this.parts.push(part); }
toString() { return this.parts.join(''); }
}
export class NumberParseError extends Error {
constructor(message) {
super();
this.message = message;
}
toString() { return this.message; }
}
export class NumberWrapper {
static toFixed(n, fractionDigits) { return n.toFixed(fractionDigits); }
static equal(a, b) { return a === b; }
static parseIntAutoRadix(text) {
var result = parseInt(text);
if (isNaN(result)) {
throw new NumberParseError('Invalid integer literal when parsing ' + text);
}
return result;
}
static parseInt(text, radix) {
if (radix == 10) {
if (/^(\-|\+)?[0-9]+$/.test(text)) {
return parseInt(text, radix);
}
}
else if (radix == 16) {
if (/^(\-|\+)?[0-9ABCDEFabcdef]+$/.test(text)) {
return parseInt(text, radix);
}
}
else {
var result = parseInt(text, radix);
if (!isNaN(result)) {
return result;
}
}
throw new NumberParseError('Invalid integer literal when parsing ' + text + ' in base ' + radix);
}
// TODO: NaN is a valid literal but is returned by parseFloat to indicate an error.
static parseFloat(text) { return parseFloat(text); }
static get NaN() { return NaN; }
static isNaN(value) { return isNaN(value); }
static isInteger(value) { return Number.isInteger(value); }
}
export var RegExp = _global.RegExp;
export class RegExpWrapper {
static create(regExpStr, flags = '') {
flags = flags.replace(/g/g, '');
return new _global.RegExp(regExpStr, flags + 'g');
}
static firstMatch(regExp, input) {
// Reset multimatch regex state
regExp.lastIndex = 0;
return regExp.exec(input);
}
static test(regExp, input) {
regExp.lastIndex = 0;
return regExp.test(input);
}
static matcher(regExp, input) {
// Reset regex state for the case
// someone did not loop over all matches
// last time.
regExp.lastIndex = 0;
return { re: regExp, input: input };
}
static replaceAll(regExp, input, replace) {
let c = regExp.exec(input);
let res = '';
regExp.lastIndex = 0;
let prev = 0;
while (c) {
res += input.substring(prev, c.index);
res += replace(c);
prev = c.index + c[0].length;
regExp.lastIndex = prev;
c = regExp.exec(input);
}
res += input.substring(prev);
return res;
}
}
export class RegExpMatcherWrapper {
static next(matcher) {
return matcher.re.exec(matcher.input);
}
}
export class FunctionWrapper {
static apply(fn, posArgs) { return fn.apply(null, posArgs); }
static bind(fn, scope) { return fn.bind(scope); }
}
// JS has NaN !== NaN
export function looseIdentical(a, b) {
return a === b || typeof a === 'number' && typeof b === 'number' && isNaN(a) && isNaN(b);
}
// JS considers NaN is the same as NaN for map Key (while NaN !== NaN otherwise)
// see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
export function getMapKey(value) {
return value;
}
export function normalizeBlank(obj) {
return isBlank(obj) ? null : obj;
}
export function normalizeBool(obj) {
return isBlank(obj) ? false : obj;
}
export function isJsObject(o) {
return o !== null && (typeof o === 'function' || typeof o === 'object');
}
export function print(obj) {
console.log(obj);
}
export function warn(obj) {
console.warn(obj);
}
// Can't be all uppercase as our transpiler would think it is a special directive...
export class Json {
static parse(s) { return _global.JSON.parse(s); }
static stringify(data) {
// Dart doesn't take 3 arguments
return _global.JSON.stringify(data, null, 2);
}
}
export class DateWrapper {
static create(year, month = 1, day = 1, hour = 0, minutes = 0, seconds = 0, milliseconds = 0) {
return new Date(year, month - 1, day, hour, minutes, seconds, milliseconds);
}
static fromISOString(str) { return new Date(str); }
static fromMillis(ms) { return new Date(ms); }
static toMillis(date) { return date.getTime(); }
static now() { return new Date(); }
static toJson(date) { return date.toJSON(); }
}
export function setValueOnPath(global, path, value) {
var parts = path.split('.');
var obj = global;
while (parts.length > 1) {
var name = parts.shift();
if (obj.hasOwnProperty(name) && isPresent(obj[name])) {
obj = obj[name];
}
else {
obj = obj[name] = {};
}
}
if (obj === undefined || obj === null) {
obj = {};
}
obj[parts.shift()] = value;
}
var _symbolIterator = null;
export function getSymbolIterator() {
if (isBlank(_symbolIterator)) {
if (isPresent(globalScope.Symbol) && isPresent(Symbol.iterator)) {
_symbolIterator = Symbol.iterator;
}
else {
// es6-shim specific logic
var keys = Object.getOwnPropertyNames(Map.prototype);
for (var i = 0; i < keys.length; ++i) {
var key = keys[i];
if (key !== 'entries' && key !== 'size' &&
Map.prototype[key] === Map.prototype['entries']) {
_symbolIterator = key;
}
}
}
}
return _symbolIterator;
}
export function evalExpression(sourceUrl, expr, declarations, vars) {
var fnBody = `${declarations}\nreturn ${expr}\n//# sourceURL=${sourceUrl}`;
var fnArgNames = [];
var fnArgValues = [];
for (var argName in vars) {
fnArgNames.push(argName);
fnArgValues.push(vars[argName]);
}
return new Function(...fnArgNames.concat(fnBody))(...fnArgValues);
}
export function isPrimitive(obj) {
return !isJsObject(obj);
}
export function hasConstructor(value, type) {
return value.constructor === type;
}
export function bitWiseOr(values) {
return values.reduce((a, b) => { return a | b; });
}
export function bitWiseAnd(values) {
return values.reduce((a, b) => { return a & b; });
}
export function escape(s) {
return _global.encodeURI(s);
}
//# sourceMappingURL=lang.js.map