"Fossies" - the Fresh Open Source Software Archive

Member "Atom/resources/app/apm/node_modules/emissary/lib/signal.js" (11 Apr 2017, 9341 Bytes) of package /windows/misc/atom-windows.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Javascript source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 (function() {
    2   var Behavior, Emitter, Signal, Subscriber, isEqual,
    3     __hasProp = {}.hasOwnProperty,
    4     __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
    5     __slice = [].slice;
    6 
    7   isEqual = require('underscore-plus').isEqual;
    8 
    9   Emitter = require('./emitter');
   10 
   11   Subscriber = require('./subscriber');
   12 
   13   Behavior = null;
   14 
   15   module.exports = Signal = (function(_super) {
   16     __extends(Signal, _super);
   17 
   18     Subscriber.includeInto(Signal);
   19 
   20     Signal.fromEmitter = function(emitter, eventName) {
   21       return new Signal(function() {
   22         var _this = this;
   23         return this.subscribe(emitter, eventName, function() {
   24           var metadata, value;
   25           value = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
   26           return _this.emitValue.apply(_this, [value].concat(__slice.call(metadata)));
   27         });
   28       });
   29     };
   30 
   31     function Signal(subscribeCallback) {
   32       var _this = this;
   33       this.subscribeCallback = subscribeCallback;
   34       this.retainCount = 0;
   35       this.on('value-subscription-will-be-added', function() {
   36         return _this.retain();
   37       });
   38       this.on('value-subscription-removed', function() {
   39         return _this.release();
   40       });
   41     }
   42 
   43     Signal.prototype.isSignal = true;
   44 
   45     Signal.prototype.retained = function() {
   46       return typeof this.subscribeCallback === "function" ? this.subscribeCallback() : void 0;
   47     };
   48 
   49     Signal.prototype.released = function() {
   50       return this.unsubscribe();
   51     };
   52 
   53     Signal.prototype.retain = function() {
   54       if (++this.retainCount === 1) {
   55         if (typeof this.retained === "function") {
   56           this.retained();
   57         }
   58       }
   59       return this;
   60     };
   61 
   62     Signal.prototype.release = function() {
   63       if (--this.retainCount === 0) {
   64         if (typeof this.released === "function") {
   65           this.released();
   66         }
   67       }
   68       return this;
   69     };
   70 
   71     Signal.prototype.onValue = function(handler) {
   72       return this.on('value', handler);
   73     };
   74 
   75     Signal.prototype.emitValue = function(value, metadata) {
   76       if (metadata == null) {
   77         metadata = {};
   78       }
   79       if (metadata.source == null) {
   80         metadata.source = this;
   81       }
   82       return this.emit('value', value, metadata);
   83     };
   84 
   85     Signal.prototype.toBehavior = function(initialValue) {
   86       var source;
   87       source = this;
   88       return this.buildBehavior(initialValue, function() {
   89         var _this = this;
   90         return this.subscribe(source, 'value', function() {
   91           var metadata, value;
   92           value = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
   93           return _this.emitValue.apply(_this, [value].concat(__slice.call(metadata)));
   94         });
   95       });
   96     };
   97 
   98     Signal.prototype.changes = function() {
   99       return this;
  100     };
  101 
  102     Signal.prototype.injectMetadata = function(fn) {
  103       var source;
  104       source = this;
  105       return new this.constructor(function() {
  106         var _this = this;
  107         return this.subscribe(source, 'value', function(value, metadata) {
  108           var k, newMetadata, v;
  109           newMetadata = fn(value, metadata);
  110           for (k in newMetadata) {
  111             v = newMetadata[k];
  112             metadata[k] = v;
  113           }
  114           return _this.emitValue(value, metadata);
  115         });
  116       });
  117     };
  118 
  119     Signal.prototype.filter = function(predicate) {
  120       var source;
  121       source = this;
  122       return new this.constructor(function() {
  123         var _this = this;
  124         return this.subscribe(source, 'value', function() {
  125           var metadata, value;
  126           value = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
  127           if (predicate.call(value, value)) {
  128             return _this.emitValue.apply(_this, [value].concat(__slice.call(metadata)));
  129           }
  130         });
  131       });
  132     };
  133 
  134     Signal.prototype.filterDefined = function() {
  135       return this.filter(function(value) {
  136         return value != null;
  137       });
  138     };
  139 
  140     Signal.prototype.map = function(fn) {
  141       var property, source;
  142       if (typeof fn === 'string') {
  143         property = fn;
  144         fn = function(value) {
  145           return value != null ? value[property] : void 0;
  146         };
  147       }
  148       source = this;
  149       return new this.constructor(function() {
  150         var _this = this;
  151         return this.subscribe(source, 'value', function() {
  152           var metadata, value;
  153           value = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
  154           return _this.emitValue.apply(_this, [fn.call(value, value)].concat(__slice.call(metadata)));
  155         });
  156       });
  157     };
  158 
  159     Signal.prototype["switch"] = function(fn) {
  160       var source;
  161       source = this.map(fn);
  162       return new this.constructor(function() {
  163         var currentSignal,
  164           _this = this;
  165         currentSignal = null;
  166         return this.subscribe(source, 'value', function(newSignal, outerMetadata) {
  167           if (currentSignal != null) {
  168             _this.unsubscribe(currentSignal);
  169           }
  170           currentSignal = newSignal;
  171           if (currentSignal != null) {
  172             return _this.subscribe(currentSignal, 'value', function(value, innerMetadata) {
  173               return _this.emitValue(value, innerMetadata);
  174             });
  175           } else {
  176             return _this.emitValue(void 0, outerMetadata);
  177           }
  178         });
  179       });
  180     };
  181 
  182     Signal.prototype.skipUntil = function(predicateOrTargetValue) {
  183       var doneSkipping, predicate, targetValue;
  184       if (typeof predicateOrTargetValue !== 'function') {
  185         targetValue = predicateOrTargetValue;
  186         return this.skipUntil(function(value) {
  187           return isEqual(value, targetValue);
  188         });
  189       }
  190       predicate = predicateOrTargetValue;
  191       doneSkipping = false;
  192       return this.filter(function(value) {
  193         if (doneSkipping) {
  194           return true;
  195         }
  196         if (predicate(value)) {
  197           return doneSkipping = true;
  198         } else {
  199           return false;
  200         }
  201       });
  202     };
  203 
  204     Signal.prototype.scan = function(initialValue, fn) {
  205       var source;
  206       source = this;
  207       return this.buildBehavior(initialValue, function() {
  208         var oldValue,
  209           _this = this;
  210         oldValue = initialValue;
  211         return this.subscribe(source, 'value', function() {
  212           var metadata, newValue;
  213           newValue = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
  214           return _this.emitValue.apply(_this, [(oldValue = fn(oldValue, newValue))].concat(__slice.call(metadata)));
  215         });
  216       });
  217     };
  218 
  219     Signal.prototype.diff = function(initialValue, fn) {
  220       var source;
  221       source = this;
  222       return this.buildBehavior(function() {
  223         var oldValue,
  224           _this = this;
  225         oldValue = initialValue;
  226         return this.subscribe(source, 'value', function() {
  227           var fnOldValue, metadata, newValue;
  228           newValue = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
  229           fnOldValue = oldValue;
  230           oldValue = newValue;
  231           return _this.emitValue.apply(_this, [fn(fnOldValue, newValue)].concat(__slice.call(metadata)));
  232         });
  233       });
  234     };
  235 
  236     Signal.prototype.distinctUntilChanged = function() {
  237       var source;
  238       source = this;
  239       return new this.constructor(function() {
  240         var oldValue, receivedValue,
  241           _this = this;
  242         receivedValue = false;
  243         oldValue = void 0;
  244         return this.subscribe(source, 'value', function() {
  245           var metadata, newValue;
  246           newValue = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
  247           if (receivedValue) {
  248             if (isEqual(oldValue, newValue)) {
  249               return oldValue = newValue;
  250             } else {
  251               oldValue = newValue;
  252               return _this.emitValue.apply(_this, [newValue].concat(__slice.call(metadata)));
  253             }
  254           } else {
  255             receivedValue = true;
  256             oldValue = newValue;
  257             return _this.emitValue.apply(_this, [newValue].concat(__slice.call(metadata)));
  258           }
  259         });
  260       });
  261     };
  262 
  263     Signal.prototype.equals = function(expected) {
  264       return this.map(function(actual) {
  265         return isEqual(actual, expected);
  266       }).distinctUntilChanged();
  267     };
  268 
  269     Signal.prototype.isDefined = function() {
  270       return this.map(function(value) {
  271         return value != null;
  272       }).distinctUntilChanged();
  273     };
  274 
  275     Signal.prototype.buildBehavior = function() {
  276       var args;
  277       args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
  278       if (Behavior == null) {
  279         Behavior = require('./behavior');
  280       }
  281       return (function(func, args, ctor) {
  282         ctor.prototype = func.prototype;
  283         var child = new ctor, result = func.apply(child, args);
  284         return Object(result) === result ? result : child;
  285       })(Behavior, args, function(){});
  286     };
  287 
  288     return Signal;
  289 
  290   })(Emitter);
  291 
  292 }).call(this);