354 lines
12 KiB
JavaScript
354 lines
12 KiB
JavaScript
//////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// This is a generated file. You can view the original //
|
|
// source in your browser if your browser supports source maps. //
|
|
// Source maps are supported by all recent versions of Chrome, Safari, //
|
|
// and Firefox, and by Internet Explorer 11. //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
(function () {
|
|
|
|
/* Imports */
|
|
var Meteor = Package.meteor.Meteor;
|
|
var global = Package.meteor.global;
|
|
var meteorEnv = Package.meteor.meteorEnv;
|
|
var meteorInstall = Package.modules.meteorInstall;
|
|
var meteorBabelHelpers = Package['babel-runtime'].meteorBabelHelpers;
|
|
var Promise = Package.promise.Promise;
|
|
var Symbol = Package['ecmascript-runtime-client'].Symbol;
|
|
var Map = Package['ecmascript-runtime-client'].Map;
|
|
var Set = Package['ecmascript-runtime-client'].Set;
|
|
var WebApp = Package.webapp.WebApp;
|
|
var Log = Package.logging.Log;
|
|
var Tracker = Package.deps.Tracker;
|
|
var Deps = Package.deps.Deps;
|
|
var Session = Package.session.Session;
|
|
var DDP = Package['ddp-client'].DDP;
|
|
var Mongo = Package.mongo.Mongo;
|
|
var Blaze = Package.ui.Blaze;
|
|
var UI = Package.ui.UI;
|
|
var Handlebars = Package.ui.Handlebars;
|
|
var Spacebars = Package.spacebars.Spacebars;
|
|
var Template = Package['templating-runtime'].Template;
|
|
var check = Package.check.check;
|
|
var Match = Package.check.Match;
|
|
var _ = Package.underscore._;
|
|
var $ = Package.jquery.$;
|
|
var jQuery = Package.jquery.jQuery;
|
|
var Random = Package.random.Random;
|
|
var EJSON = Package.ejson.EJSON;
|
|
var LaunchScreen = Package['launch-screen'].LaunchScreen;
|
|
var HTML = Package.htmljs.HTML;
|
|
|
|
var require = meteorInstall({"node_modules":{"meteor":{"ohif:log":{"main.js":function(require,exports,module){
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/ohif_log/main.js //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
var Meteor;
|
|
module.watch(require("meteor/meteor"), {
|
|
Meteor: function (v) {
|
|
Meteor = v;
|
|
}
|
|
}, 0);
|
|
var OHIF;
|
|
module.watch(require("meteor/ohif:core"), {
|
|
OHIF: function (v) {
|
|
OHIF = v;
|
|
}
|
|
}, 1);
|
|
var loglevel;
|
|
module.watch(require("loglevel"), {
|
|
"default": function (v) {
|
|
loglevel = v;
|
|
}
|
|
}, 2);
|
|
var defaultLevel = Meteor.isProduction ? 'ERROR' : 'TRACE'; // Create package logger using loglevel
|
|
|
|
OHIF.log = loglevel.getLogger('OHIF');
|
|
OHIF.log.setLevel(defaultLevel); // Add time and timeEnd to OHIF.log namespace
|
|
|
|
var times = new Map(); // Register the time method
|
|
|
|
OHIF.log.time = function (givenKey) {
|
|
var key = typeof givenKey === 'undefined' ? 'default' : givenKey;
|
|
times.set(key, new Date().getTime());
|
|
}; // Register the timeEnd method
|
|
|
|
|
|
OHIF.log.timeEnd = function (givenKey) {
|
|
var key = typeof givenKey === 'undefined' ? 'default' : givenKey;
|
|
var now = new Date().getTime();
|
|
var last = times.get(key) || now;
|
|
times.delete(key);
|
|
var duration = now - last;
|
|
OHIF.log.info(key + ": " + duration + "ms");
|
|
};
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
},"node_modules":{"loglevel":{"package.json":function(require,exports){
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// node_modules/meteor/ohif_log/node_modules/loglevel/package.json //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
exports.name = "loglevel";
|
|
exports.version = "1.4.1";
|
|
exports.main = "lib/loglevel";
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
},"lib":{"loglevel.js":function(require,exports,module){
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// node_modules/meteor/ohif_log/node_modules/loglevel/lib/loglevel.js //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
/*
|
|
* loglevel - https://github.com/pimterry/loglevel
|
|
*
|
|
* Copyright (c) 2013 Tim Perry
|
|
* Licensed under the MIT license.
|
|
*/
|
|
(function (root, definition) {
|
|
"use strict";
|
|
if (typeof define === 'function' && define.amd) {
|
|
define(definition);
|
|
} else if (typeof module === 'object' && module.exports) {
|
|
module.exports = definition();
|
|
} else {
|
|
root.log = definition();
|
|
}
|
|
}(this, function () {
|
|
"use strict";
|
|
var noop = function() {};
|
|
var undefinedType = "undefined";
|
|
|
|
function realMethod(methodName) {
|
|
if (typeof console === undefinedType) {
|
|
return false; // We can't build a real method without a console to log to
|
|
} else if (console[methodName] !== undefined) {
|
|
return bindMethod(console, methodName);
|
|
} else if (console.log !== undefined) {
|
|
return bindMethod(console, 'log');
|
|
} else {
|
|
return noop;
|
|
}
|
|
}
|
|
|
|
function bindMethod(obj, methodName) {
|
|
var method = obj[methodName];
|
|
if (typeof method.bind === 'function') {
|
|
return method.bind(obj);
|
|
} else {
|
|
try {
|
|
return Function.prototype.bind.call(method, obj);
|
|
} catch (e) {
|
|
// Missing bind shim or IE8 + Modernizr, fallback to wrapping
|
|
return function() {
|
|
return Function.prototype.apply.apply(method, [obj, arguments]);
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
// these private functions always need `this` to be set properly
|
|
|
|
function enableLoggingWhenConsoleArrives(methodName, level, loggerName) {
|
|
return function () {
|
|
if (typeof console !== undefinedType) {
|
|
replaceLoggingMethods.call(this, level, loggerName);
|
|
this[methodName].apply(this, arguments);
|
|
}
|
|
};
|
|
}
|
|
|
|
function replaceLoggingMethods(level, loggerName) {
|
|
/*jshint validthis:true */
|
|
for (var i = 0; i < logMethods.length; i++) {
|
|
var methodName = logMethods[i];
|
|
this[methodName] = (i < level) ?
|
|
noop :
|
|
this.methodFactory(methodName, level, loggerName);
|
|
}
|
|
}
|
|
|
|
function defaultMethodFactory(methodName, level, loggerName) {
|
|
/*jshint validthis:true */
|
|
return realMethod(methodName) ||
|
|
enableLoggingWhenConsoleArrives.apply(this, arguments);
|
|
}
|
|
|
|
var logMethods = [
|
|
"trace",
|
|
"debug",
|
|
"info",
|
|
"warn",
|
|
"error"
|
|
];
|
|
|
|
function Logger(name, defaultLevel, factory) {
|
|
var self = this;
|
|
var currentLevel;
|
|
var storageKey = "loglevel";
|
|
if (name) {
|
|
storageKey += ":" + name;
|
|
}
|
|
|
|
function persistLevelIfPossible(levelNum) {
|
|
var levelName = (logMethods[levelNum] || 'silent').toUpperCase();
|
|
|
|
// Use localStorage if available
|
|
try {
|
|
window.localStorage[storageKey] = levelName;
|
|
return;
|
|
} catch (ignore) {}
|
|
|
|
// Use session cookie as fallback
|
|
try {
|
|
window.document.cookie =
|
|
encodeURIComponent(storageKey) + "=" + levelName + ";";
|
|
} catch (ignore) {}
|
|
}
|
|
|
|
function getPersistedLevel() {
|
|
var storedLevel;
|
|
|
|
try {
|
|
storedLevel = window.localStorage[storageKey];
|
|
} catch (ignore) {}
|
|
|
|
if (typeof storedLevel === undefinedType) {
|
|
try {
|
|
var cookie = window.document.cookie;
|
|
var location = cookie.indexOf(
|
|
encodeURIComponent(storageKey) + "=");
|
|
if (location) {
|
|
storedLevel = /^([^;]+)/.exec(cookie.slice(location))[1];
|
|
}
|
|
} catch (ignore) {}
|
|
}
|
|
|
|
// If the stored level is not valid, treat it as if nothing was stored.
|
|
if (self.levels[storedLevel] === undefined) {
|
|
storedLevel = undefined;
|
|
}
|
|
|
|
return storedLevel;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Public API
|
|
*
|
|
*/
|
|
|
|
self.levels = { "TRACE": 0, "DEBUG": 1, "INFO": 2, "WARN": 3,
|
|
"ERROR": 4, "SILENT": 5};
|
|
|
|
self.methodFactory = factory || defaultMethodFactory;
|
|
|
|
self.getLevel = function () {
|
|
return currentLevel;
|
|
};
|
|
|
|
self.setLevel = function (level, persist) {
|
|
if (typeof level === "string" && self.levels[level.toUpperCase()] !== undefined) {
|
|
level = self.levels[level.toUpperCase()];
|
|
}
|
|
if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
|
|
currentLevel = level;
|
|
if (persist !== false) { // defaults to true
|
|
persistLevelIfPossible(level);
|
|
}
|
|
replaceLoggingMethods.call(self, level, name);
|
|
if (typeof console === undefinedType && level < self.levels.SILENT) {
|
|
return "No console available for logging";
|
|
}
|
|
} else {
|
|
throw "log.setLevel() called with invalid level: " + level;
|
|
}
|
|
};
|
|
|
|
self.setDefaultLevel = function (level) {
|
|
if (!getPersistedLevel()) {
|
|
self.setLevel(level, false);
|
|
}
|
|
};
|
|
|
|
self.enableAll = function(persist) {
|
|
self.setLevel(self.levels.TRACE, persist);
|
|
};
|
|
|
|
self.disableAll = function(persist) {
|
|
self.setLevel(self.levels.SILENT, persist);
|
|
};
|
|
|
|
// Initialize with the right level
|
|
var initialLevel = getPersistedLevel();
|
|
if (initialLevel == null) {
|
|
initialLevel = defaultLevel == null ? "WARN" : defaultLevel;
|
|
}
|
|
self.setLevel(initialLevel, false);
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Package-level API
|
|
*
|
|
*/
|
|
|
|
var defaultLogger = new Logger();
|
|
|
|
var _loggersByName = {};
|
|
defaultLogger.getLogger = function getLogger(name) {
|
|
if (typeof name !== "string" || name === "") {
|
|
throw new TypeError("You must supply a name when creating a logger.");
|
|
}
|
|
|
|
var logger = _loggersByName[name];
|
|
if (!logger) {
|
|
logger = _loggersByName[name] = new Logger(
|
|
name, defaultLogger.getLevel(), defaultLogger.methodFactory);
|
|
}
|
|
return logger;
|
|
};
|
|
|
|
// Grab the current global log variable in case of overwrite
|
|
var _log = (typeof window !== undefinedType) ? window.log : undefined;
|
|
defaultLogger.noConflict = function() {
|
|
if (typeof window !== undefinedType &&
|
|
window.log === defaultLogger) {
|
|
window.log = _log;
|
|
}
|
|
|
|
return defaultLogger;
|
|
};
|
|
|
|
return defaultLogger;
|
|
}));
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}}}}}}}},{
|
|
"extensions": [
|
|
".js",
|
|
".json"
|
|
]
|
|
});
|
|
require("/node_modules/meteor/ohif:log/main.js");
|
|
|
|
/* Exports */
|
|
Package._define("ohif:log");
|
|
|
|
})();
|