"Fossies" - the Fresh Open Source Software Archive

Member "Atom/resources/app/apm/node_modules/emissary/lib/behavior.js" (7 Feb 2017, 3978 Bytes) of archive /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, PropertyAccessors, Signal, helpers, 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   PropertyAccessors = require('property-accessors');
   10 
   11   Signal = require('./signal');
   12 
   13   module.exports = Behavior = (function(_super) {
   14     __extends(Behavior, _super);
   15 
   16     PropertyAccessors.includeInto(Behavior);
   17 
   18     function Behavior() {
   19       var args, subscribeCallback, _ref;
   20       args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
   21       if (typeof ((_ref = args[0]) != null ? _ref.call : void 0) !== 'function') {
   22         this.value = args.shift();
   23       }
   24       Behavior.__super__.constructor.call(this, subscribeCallback = args.shift());
   25     }
   26 
   27     Behavior.prototype.retained = function() {
   28       var _this = this;
   29       this.subscribe(this, 'value-internal', function(value) {
   30         return _this.value = value;
   31       });
   32       this.subscribe(this, 'value-subscription-added', function(handler) {
   33         return handler(_this.value);
   34       });
   35       return typeof this.subscribeCallback === "function" ? this.subscribeCallback() : void 0;
   36     };
   37 
   38     Behavior.prototype.emit = function() {
   39       var args, name;
   40       name = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
   41       if (name === 'value') {
   42         this.emit.apply(this, ['value-internal'].concat(__slice.call(args)));
   43       }
   44       return Behavior.__super__.emit.apply(this, arguments);
   45     };
   46 
   47     Behavior.prototype.getValue = function() {
   48       if (!(this.retainCount > 0)) {
   49         throw new Error("Subscribe to or retain this behavior before calling getValue");
   50       }
   51       return this.value;
   52     };
   53 
   54     Behavior.prototype.and = function(right) {
   55       return helpers.combine(this, right, (function(leftValue, rightValue) {
   56         return leftValue && rightValue;
   57       })).distinctUntilChanged();
   58     };
   59 
   60     Behavior.prototype.or = function(right) {
   61       return helpers.combine(this, right, (function(leftValue, rightValue) {
   62         return leftValue || rightValue;
   63       })).distinctUntilChanged();
   64     };
   65 
   66     Behavior.prototype.toBehavior = function() {
   67       return this;
   68     };
   69 
   70     Behavior.prototype.lazyAccessor('changes', function() {
   71       var source;
   72       source = this;
   73       return new Signal(function() {
   74         var gotFirst,
   75           _this = this;
   76         gotFirst = false;
   77         return this.subscribe(source, 'value', function() {
   78           var metadata, value;
   79           value = arguments[0], metadata = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
   80           if (gotFirst) {
   81             _this.emitValue.apply(_this, [value].concat(__slice.call(metadata)));
   82           }
   83           return gotFirst = true;
   84         });
   85       });
   86     });
   87 
   88     Behavior.prototype.becomes = function(predicateOrTargetValue) {
   89       var predicate, targetValue;
   90       if (typeof predicateOrTargetValue !== 'function') {
   91         targetValue = predicateOrTargetValue;
   92         return this.becomes(function(value) {
   93           return isEqual(value, targetValue);
   94         });
   95       }
   96       predicate = predicateOrTargetValue;
   97       return this.map(function(value) {
   98         return !!predicate(value);
   99       }).distinctUntilChanged().changes;
  100     };
  101 
  102     Behavior.prototype.becomesLessThan = function(targetValue) {
  103       return this.becomes(function(value) {
  104         return value < targetValue;
  105       });
  106     };
  107 
  108     Behavior.prototype.becomesGreaterThan = function(targetValue) {
  109       return this.becomes(function(value) {
  110         return value > targetValue;
  111       });
  112     };
  113 
  114     return Behavior;
  115 
  116   })(Signal);
  117 
  118   helpers = require('./helpers');
  119 
  120 }).call(this);