upgrade dojo to 1.8.3 (refs #570)

[tt-rss.git] / lib / dojo / promise / instrumentation.js.uncompressed.js

diff --git a/lib/dojo/promise/instrumentation.js.uncompressed.js b/lib/dojo/promise/instrumentation.js.uncompressed.js
new file mode 100644 (file)
index 0000000..b32bb98
--- /dev/null
+++ b/lib/dojo/promise/instrumentation.js.uncompressed.js
@@ -0,0 +1,105 @@
+define("dojo/promise/instrumentation", [
+       "./tracer",
+       "../has",
+       "../_base/lang",
+       "../_base/array"
+], function(tracer, has, lang, arrayUtil){
+       function logError(error, rejection, deferred){
+               var stack = "";
+               if(error && error.stack){
+                       stack += error.stack;
+               }
+               if(rejection && rejection.stack){
+                       stack += "\n    ----------------------------------------\n    rejected" + rejection.stack.split("\n").slice(1).join("\n").replace(/^\s+/, " ");
+               }
+               if(deferred && deferred.stack){
+                       stack += "\n    ----------------------------------------\n" + deferred.stack;
+               }
+               console.error(error, stack);
+       }
+
+       function reportRejections(error, handled, rejection, deferred){
+               if(!handled){
+                       logError(error, rejection, deferred);
+               }
+       }
+
+       var errors = [];
+       var activeTimeout = false;
+       var unhandledWait = 1000;
+       function trackUnhandledRejections(error, handled, rejection, deferred){
+               if(handled){
+                       arrayUtil.some(errors, function(obj, ix){
+                               if(obj.error === error){
+                                       errors.splice(ix, 1);
+                                       return true;
+                               }
+                       });
+               }else if(!arrayUtil.some(errors, function(obj){ return obj.error === error; })){
+                       errors.push({
+                               error: error,
+                               rejection: rejection,
+                               deferred: deferred,
+                               timestamp: new Date().getTime()
+                       });
+               }
+
+               if(!activeTimeout){
+                       activeTimeout = setTimeout(logRejected, unhandledWait);
+               }
+       }
+
+       function logRejected(){
+               var now = new Date().getTime();
+               var reportBefore = now - unhandledWait;
+               errors = arrayUtil.filter(errors, function(obj){
+                       if(obj.timestamp < reportBefore){
+                               logError(obj.error, obj.rejection, obj.deferred);
+                               return false;
+                       }
+                       return true;
+               });
+
+               if(errors.length){
+                       activeTimeout = setTimeout(logRejected, errors[0].timestamp + unhandledWait - now);
+               }else{
+                       activeTimeout = false;
+               }
+       }
+
+       return function(Deferred){
+               // summary:
+               //              Initialize instrumentation for the Deferred class.
+               // description:
+               //              Initialize instrumentation for the Deferred class.
+               //              Done automatically by `dojo/Deferred` if the
+               //              `deferredInstrumentation` and `useDeferredInstrumentation`
+               //              config options are set.
+               //
+               //              Sets up `dojo/promise/tracer` to log to the console.
+               //
+               //              Sets up instrumentation of rejected deferreds so unhandled
+               //              errors are logged to the console.
+
+               var usage = has("config-useDeferredInstrumentation");
+               if(usage){
+                       tracer.on("resolved", lang.hitch(console, "log", "resolved"));
+                       tracer.on("rejected", lang.hitch(console, "log", "rejected"));
+                       tracer.on("progress", lang.hitch(console, "log", "progress"));
+
+                       var args = [];
+                       if(typeof usage === "string"){
+                               args = usage.split(",");
+                               usage = args.shift();
+                       }
+                       if(usage === "report-rejections"){
+                               Deferred.instrumentRejected = reportRejections;
+                       }else if(usage === "report-unhandled-rejections" || usage === true || usage === 1){
+                               Deferred.instrumentRejected = trackUnhandledRejections;
+                               unhandledWait = parseInt(args[0], 10) || unhandledWait;
+                       }else{
+                               throw new Error("Unsupported instrumentation usage <" + usage + ">");
+                       }
+               }
+       };
+});