BVB Source Codes

reactide Show raw.js Source code

Return Download reactide: download raw.js Source code - Download reactide Source code - Type:.js
  1. "use strict";
  2.  
  3. var domain; // The domain module is executed on demand
  4. var hasSetImmediate = typeof setImmediate === "function";
  5.  
  6. // Use the fastest means possible to execute a task in its own turn, with
  7. // priority over other events including network IO events in Node.js.
  8. //
  9. // An exception thrown by a task will permanently interrupt the processing of
  10. // subsequent tasks. The higher level `asap` function ensures that if an
  11. // exception is thrown by a task, that the task queue will continue flushing as
  12. // soon as possible, but if you use `rawAsap` directly, you are responsible to
  13. // either ensure that no exceptions are thrown from your task, or to manually
  14. // call `rawAsap.requestFlush` if an exception is thrown.
  15. module.exports = rawAsap;
  16. function rawAsap(task) {
  17.     if (!queue.length) {
  18.         requestFlush();
  19.         flushing = true;
  20.     }
  21.     // Avoids a function call
  22.     queue[queue.length] = task;
  23. }
  24.  
  25. var queue = [];
  26. // Once a flush has been requested, no further calls to `requestFlush` are
  27. // necessary until the next `flush` completes.
  28. var flushing = false;
  29. // The position of the next task to execute in the task queue. This is
  30. // preserved between calls to `flush` so that it can be resumed if
  31. // a task throws an exception.
  32. var index = 0;
  33. // If a task schedules additional tasks recursively, the task queue can grow
  34. // unbounded. To prevent memory excaustion, the task queue will periodically
  35. // truncate already-completed tasks.
  36. var capacity = 1024;
  37.  
  38. // The flush function processes all tasks that have been scheduled with
  39. // `rawAsap` unless and until one of those tasks throws an exception.
  40. // If a task throws an exception, `flush` ensures that its state will remain
  41. // consistent and will resume where it left off when called again.
  42. // However, `flush` does not make any arrangements to be called again if an
  43. // exception is thrown.
  44. function flush() {
  45.     while (index < queue.length) {
  46.         var currentIndex = index;
  47.         // Advance the index before calling the task. This ensures that we will
  48.         // begin flushing on the next task the task throws an error.
  49.         index = index + 1;
  50.         queue[currentIndex].call();
  51.         // Prevent leaking memory for long chains of recursive calls to `asap`.
  52.         // If we call `asap` within tasks scheduled by `asap`, the queue will
  53.         // grow, but to avoid an O(n) walk for every task we execute, we don't
  54.         // shift tasks off the queue after they have been executed.
  55.         // Instead, we periodically shift 1024 tasks off the queue.
  56.         if (index > capacity) {
  57.             // Manually shift all values starting at the index back to the
  58.             // beginning of the queue.
  59.             for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {
  60.                 queue[scan] = queue[scan + index];
  61.             }
  62.             queue.length -= index;
  63.             index = 0;
  64.         }
  65.     }
  66.     queue.length = 0;
  67.     index = 0;
  68.     flushing = false;
  69. }
  70.  
  71. rawAsap.requestFlush = requestFlush;
  72. function requestFlush() {
  73.     // Ensure flushing is not bound to any domain.
  74.     // It is not sufficient to exit the domain, because domains exist on a stack.
  75.     // To execute code outside of any domain, the following dance is necessary.
  76.     var parentDomain = process.domain;
  77.     if (parentDomain) {
  78.         if (!domain) {
  79.             // Lazy execute the domain module.
  80.             // Only employed if the user elects to use domains.
  81.             domain = require("domain");
  82.         }
  83.         domain.active = process.domain = null;
  84.     }
  85.  
  86.     // `setImmediate` is slower that `process.nextTick`, but `process.nextTick`
  87.     // cannot handle recursion.
  88.     // `requestFlush` will only be called recursively from `asap.js`, to resume
  89.     // flushing after an error is thrown into a domain.
  90.     // Conveniently, `setImmediate` was introduced in the same version
  91.     // `process.nextTick` started throwing recursion errors.
  92.     if (flushing && hasSetImmediate) {
  93.         setImmediate(flush);
  94.     } else {
  95.         process.nextTick(flush);
  96.     }
  97.  
  98.     if (parentDomain) {
  99.         domain.active = process.domain = parentDomain;
  100.     }
  101. }
  102.  
downloadraw.js Source code - Download reactide Source code
Related Source Codes/Software:
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
postal - 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top