yaffs.net Git - yaffs-website/blob - web/core/misc/states.js

   1 /**
   2 * DO NOT EDIT THIS FILE.
   3 * See the following change record for more information,
   4 * https://www.drupal.org/node/2815083
   5 * @preserve
   6 **/
   7
   8 (function ($, Drupal) {
   9   var states = {
  10     postponed: []
  11   };
  12
  13   Drupal.states = states;
  14
  15   function invert(a, invertState) {
  16     return invertState && typeof a !== 'undefined' ? !a : a;
  17   }
  18
  19   function _compare2(a, b) {
  20     if (a === b) {
  21       return typeof a === 'undefined' ? a : true;
  22     }
  23
  24     return typeof a === 'undefined' || typeof b === 'undefined';
  25   }
  26
  27   function ternary(a, b) {
  28     if (typeof a === 'undefined') {
  29       return b;
  30     }
  31     if (typeof b === 'undefined') {
  32       return a;
  33     }
  34
  35     return a && b;
  36   }
  37
  38   Drupal.behaviors.states = {
  39     attach: function attach(context, settings) {
  40       var $states = $(context).find('[data-drupal-states]');
  41       var il = $states.length;
  42
  43       var _loop = function _loop(i) {
  44         var config = JSON.parse($states[i].getAttribute('data-drupal-states'));
  45         Object.keys(config || {}).forEach(function (state) {
  46           new states.Dependent({
  47             element: $($states[i]),
  48             state: states.State.sanitize(state),
  49             constraints: config[state]
  50           });
  51         });
  52       };
  53
  54       for (var i = 0; i < il; i++) {
  55         _loop(i);
  56       }
  57
  58       while (states.postponed.length) {
  59         states.postponed.shift()();
  60       }
  61     }
  62   };
  63
  64   states.Dependent = function (args) {
  65     var _this = this;
  66
  67     $.extend(this, { values: {}, oldValue: null }, args);
  68
  69     this.dependees = this.getDependees();
  70     Object.keys(this.dependees || {}).forEach(function (selector) {
  71       _this.initializeDependee(selector, _this.dependees[selector]);
  72     });
  73   };
  74
  75   states.Dependent.comparisons = {
  76     RegExp: function RegExp(reference, value) {
  77       return reference.test(value);
  78     },
  79     Function: function Function(reference, value) {
  80       return reference(value);
  81     },
  82     Number: function Number(reference, value) {
  83       return typeof value === 'string' ? _compare2(reference.toString(), value) : _compare2(reference, value);
  84     }
  85   };
  86
  87   states.Dependent.prototype = {
  88     initializeDependee: function initializeDependee(selector, dependeeStates) {
  89       var _this2 = this;
  90
  91       this.values[selector] = {};
  92
  93       Object.keys(dependeeStates).forEach(function (i) {
  94         var state = dependeeStates[i];
  95
  96         if ($.inArray(state, dependeeStates) === -1) {
  97           return;
  98         }
  99
 100         state = states.State.sanitize(state);
 101
 102         _this2.values[selector][state.name] = null;
 103
 104         $(selector).on('state:' + state, { selector: selector, state: state }, function (e) {
 105           _this2.update(e.data.selector, e.data.state, e.value);
 106         });
 107
 108         new states.Trigger({ selector: selector, state: state });
 109       });
 110     },
 111     compare: function compare(reference, selector, state) {
 112       var value = this.values[selector][state.name];
 113       if (reference.constructor.name in states.Dependent.comparisons) {
 114         return states.Dependent.comparisons[reference.constructor.name](reference, value);
 115       }
 116
 117       return _compare2(reference, value);
 118     },
 119     update: function update(selector, state, value) {
 120       if (value !== this.values[selector][state.name]) {
 121         this.values[selector][state.name] = value;
 122         this.reevaluate();
 123       }
 124     },
 125     reevaluate: function reevaluate() {
 126       var value = this.verifyConstraints(this.constraints);
 127
 128       if (value !== this.oldValue) {
 129         this.oldValue = value;
 130
 131         value = invert(value, this.state.invert);
 132
 133         this.element.trigger({
 134           type: 'state:' + this.state,
 135           value: value,
 136           trigger: true
 137         });
 138       }
 139     },
 140     verifyConstraints: function verifyConstraints(constraints, selector) {
 141       var result = void 0;
 142       if ($.isArray(constraints)) {
 143         var hasXor = $.inArray('xor', constraints) === -1;
 144         var len = constraints.length;
 145         for (var i = 0; i < len; i++) {
 146           if (constraints[i] !== 'xor') {
 147             var constraint = this.checkConstraints(constraints[i], selector, i);
 148
 149             if (constraint && (hasXor || result)) {
 150               return hasXor;
 151             }
 152             result = result || constraint;
 153           }
 154         }
 155       } else if ($.isPlainObject(constraints)) {
 156           for (var n in constraints) {
 157             if (constraints.hasOwnProperty(n)) {
 158               result = ternary(result, this.checkConstraints(constraints[n], selector, n));
 159
 160               if (result === false) {
 161                 return false;
 162               }
 163             }
 164           }
 165         }
 166       return result;
 167     },
 168     checkConstraints: function checkConstraints(value, selector, state) {
 169       if (typeof state !== 'string' || /[0-9]/.test(state[0])) {
 170         state = null;
 171       } else if (typeof selector === 'undefined') {
 172         selector = state;
 173         state = null;
 174       }
 175
 176       if (state !== null) {
 177         state = states.State.sanitize(state);
 178         return invert(this.compare(value, selector, state), state.invert);
 179       }
 180
 181       return this.verifyConstraints(value, selector);
 182     },
 183     getDependees: function getDependees() {
 184       var cache = {};
 185
 186       var _compare = this.compare;
 187       this.compare = function (reference, selector, state) {
 188         (cache[selector] || (cache[selector] = [])).push(state.name);
 189       };
 190
 191       this.verifyConstraints(this.constraints);
 192
 193       this.compare = _compare;
 194
 195       return cache;
 196     }
 197   };
 198
 199   states.Trigger = function (args) {
 200     $.extend(this, args);
 201
 202     if (this.state in states.Trigger.states) {
 203       this.element = $(this.selector);
 204
 205       if (!this.element.data('trigger:' + this.state)) {
 206         this.initialize();
 207       }
 208     }
 209   };
 210
 211   states.Trigger.prototype = {
 212     initialize: function initialize() {
 213       var _this3 = this;
 214
 215       var trigger = states.Trigger.states[this.state];
 216
 217       if (typeof trigger === 'function') {
 218         trigger.call(window, this.element);
 219       } else {
 220         Object.keys(trigger || {}).forEach(function (event) {
 221           _this3.defaultTrigger(event, trigger[event]);
 222         });
 223       }
 224
 225       this.element.data('trigger:' + this.state, true);
 226     },
 227     defaultTrigger: function defaultTrigger(event, valueFn) {
 228       var oldValue = valueFn.call(this.element);
 229
 230       this.element.on(event, $.proxy(function (e) {
 231         var value = valueFn.call(this.element, e);
 232
 233         if (oldValue !== value) {
 234           this.element.trigger({
 235             type: 'state:' + this.state,
 236             value: value,
 237             oldValue: oldValue
 238           });
 239           oldValue = value;
 240         }
 241       }, this));
 242
 243       states.postponed.push($.proxy(function () {
 244         this.element.trigger({
 245           type: 'state:' + this.state,
 246           value: oldValue,
 247           oldValue: null
 248         });
 249       }, this));
 250     }
 251   };
 252
 253   states.Trigger.states = {
 254     empty: {
 255       keyup: function keyup() {
 256         return this.val() === '';
 257       }
 258     },
 259
 260     checked: {
 261       change: function change() {
 262         var checked = false;
 263         this.each(function () {
 264           checked = $(this).prop('checked');
 265
 266           return !checked;
 267         });
 268         return checked;
 269       }
 270     },
 271
 272     value: {
 273       keyup: function keyup() {
 274         if (this.length > 1) {
 275           return this.filter(':checked').val() || false;
 276         }
 277         return this.val();
 278       },
 279       change: function change() {
 280         if (this.length > 1) {
 281           return this.filter(':checked').val() || false;
 282         }
 283         return this.val();
 284       }
 285     },
 286
 287     collapsed: {
 288       collapsed: function collapsed(e) {
 289         return typeof e !== 'undefined' && 'value' in e ? e.value : !this.is('[open]');
 290       }
 291     }
 292   };
 293
 294   states.State = function (state) {
 295     this.pristine = state;
 296     this.name = state;
 297
 298     var process = true;
 299     do {
 300       while (this.name.charAt(0) === '!') {
 301         this.name = this.name.substring(1);
 302         this.invert = !this.invert;
 303       }
 304
 305       if (this.name in states.State.aliases) {
 306         this.name = states.State.aliases[this.name];
 307       } else {
 308         process = false;
 309       }
 310     } while (process);
 311   };
 312
 313   states.State.sanitize = function (state) {
 314     if (state instanceof states.State) {
 315       return state;
 316     }
 317
 318     return new states.State(state);
 319   };
 320
 321   states.State.aliases = {
 322     enabled: '!disabled',
 323     invisible: '!visible',
 324     invalid: '!valid',
 325     untouched: '!touched',
 326     optional: '!required',
 327     filled: '!empty',
 328     unchecked: '!checked',
 329     irrelevant: '!relevant',
 330     expanded: '!collapsed',
 331     open: '!collapsed',
 332     closed: 'collapsed',
 333     readwrite: '!readonly'
 334   };
 335
 336   states.State.prototype = {
 337     invert: false,
 338
 339     toString: function toString() {
 340       return this.name;
 341     }
 342   };
 343
 344   var $document = $(document);
 345   $document.on('state:disabled', function (e) {
 346     if (e.trigger) {
 347       $(e.target).prop('disabled', e.value).closest('.js-form-item, .js-form-submit, .js-form-wrapper').toggleClass('form-disabled', e.value).find('select, input, textarea').prop('disabled', e.value);
 348     }
 349   });
 350
 351   $document.on('state:required', function (e) {
 352     if (e.trigger) {
 353       if (e.value) {
 354         var label = 'label' + (e.target.id ? '[for=' + e.target.id + ']' : '');
 355         var $label = $(e.target).attr({ required: 'required', 'aria-required': 'aria-required' }).closest('.js-form-item, .js-form-wrapper').find(label);
 356
 357         if (!$label.hasClass('js-form-required').length) {
 358           $label.addClass('js-form-required form-required');
 359         }
 360       } else {
 361         $(e.target).removeAttr('required aria-required').closest('.js-form-item, .js-form-wrapper').find('label.js-form-required').removeClass('js-form-required form-required');
 362       }
 363     }
 364   });
 365
 366   $document.on('state:visible', function (e) {
 367     if (e.trigger) {
 368       $(e.target).closest('.js-form-item, .js-form-submit, .js-form-wrapper').toggle(e.value);
 369     }
 370   });
 371
 372   $document.on('state:checked', function (e) {
 373     if (e.trigger) {
 374       $(e.target).prop('checked', e.value);
 375     }
 376   });
 377
 378   $document.on('state:collapsed', function (e) {
 379     if (e.trigger) {
 380       if ($(e.target).is('[open]') === e.value) {
 381         $(e.target).find('> summary').trigger('click');
 382       }
 383     }
 384   });
 385 })(jQuery, Drupal);