resources/src/mediawiki.rcfilters/dm/mw.rcfilters.dm.FiltersViewModel.js

   1 ( function ( mw, $ ) {
   2         /**
   3          * View model for the filters selection and display
   4          *
   5          * @mixins OO.EventEmitter
   6          * @mixins OO.EmitterList
   7          *
   8          * @constructor
   9          */
  10         mw.rcfilters.dm.FiltersViewModel = function MwRcfiltersDmFiltersViewModel() {
  11                 // Mixin constructor
  12                 OO.EventEmitter.call( this );
  13                 OO.EmitterList.call( this );
  14
  15                 this.groups = {};
  16                 this.defaultParams = {};
  17                 this.defaultFiltersEmpty = null;
  18                 this.highlightEnabled = false;
  19                 this.invertedNamespaces = false;
  20                 this.parameterMap = {};
  21
  22                 this.views = {};
  23                 this.currentView = 'default';
  24
  25                 // Events
  26                 this.aggregate( { update: 'filterItemUpdate' } );
  27                 this.connect( this, { filterItemUpdate: [ 'emit', 'itemUpdate' ] } );
  28         };
  29
  30         /* Initialization */
  31         OO.initClass( mw.rcfilters.dm.FiltersViewModel );
  32         OO.mixinClass( mw.rcfilters.dm.FiltersViewModel, OO.EventEmitter );
  33         OO.mixinClass( mw.rcfilters.dm.FiltersViewModel, OO.EmitterList );
  34
  35         /* Events */
  36
  37         /**
  38          * @event initialize
  39          *
  40          * Filter list is initialized
  41          */
  42
  43         /**
  44          * @event update
  45          *
  46          * Model has been updated
  47          */
  48
  49         /**
  50          * @event itemUpdate
  51          * @param {mw.rcfilters.dm.FilterItem} item Filter item updated
  52          *
  53          * Filter item has changed
  54          */
  55
  56         /**
  57          * @event highlightChange
  58          * @param {boolean} Highlight feature is enabled
  59          *
  60          * Highlight feature has been toggled enabled or disabled
  61          */
  62
  63         /**
  64          * @event invertChange
  65          * @param {boolean} isInverted Namespace selected is inverted
  66          *
  67          * Namespace selection is inverted or straight forward
  68          */
  69
  70         /* Methods */
  71
  72         /**
  73          * Re-assess the states of filter items based on the interactions between them
  74          *
  75          * @param {mw.rcfilters.dm.FilterItem} [item] Changed item. If not given, the
  76          *  method will go over the state of all items
  77          */
  78         mw.rcfilters.dm.FiltersViewModel.prototype.reassessFilterInteractions = function ( item ) {
  79                 var allSelected,
  80                         model = this,
  81                         iterationItems = item !== undefined ? [ item ] : this.getItems();
  82
  83                 iterationItems.forEach( function ( checkedItem ) {
  84                         var allCheckedItems = checkedItem.getSubset().concat( [ checkedItem.getName() ] ),
  85                                 groupModel = checkedItem.getGroupModel();
  86
  87                         // Check for subsets (included filters) plus the item itself:
  88                         allCheckedItems.forEach( function ( filterItemName ) {
  89                                 var itemInSubset = model.getItemByName( filterItemName );
  90
  91                                 itemInSubset.toggleIncluded(
  92                                         // If any of itemInSubset's supersets are selected, this item
  93                                         // is included
  94                                         itemInSubset.getSuperset().some( function ( supersetName ) {
  95                                                 return ( model.getItemByName( supersetName ).isSelected() );
  96                                         } )
  97                                 );
  98                         } );
  99
 100                         // Update coverage for the changed group
 101                         if ( groupModel.isFullCoverage() ) {
 102                                 allSelected = groupModel.areAllSelected();
 103                                 groupModel.getItems().forEach( function ( filterItem ) {
 104                                         filterItem.toggleFullyCovered( allSelected );
 105                                 } );
 106                         }
 107                 } );
 108
 109                 // Check for conflicts
 110                 // In this case, we must go over all items, since
 111                 // conflicts are bidirectional and depend not only on
 112                 // individual items, but also on the selected states of
 113                 // the groups they're in.
 114                 this.getItems().forEach( function ( filterItem ) {
 115                         var inConflict = false,
 116                                 filterItemGroup = filterItem.getGroupModel();
 117
 118                         // For each item, see if that item is still conflicting
 119                         $.each( model.groups, function ( groupName, groupModel ) {
 120                                 if ( filterItem.getGroupName() === groupName ) {
 121                                         // Check inside the group
 122                                         inConflict = groupModel.areAnySelectedInConflictWith( filterItem );
 123                                 } else {
 124                                         // According to the spec, if two items conflict from two different
 125                                         // groups, the conflict only lasts if the groups **only have selected
 126                                         // items that are conflicting**. If a group has selected items that
 127                                         // are conflicting and non-conflicting, the scope of the result has
 128                                         // expanded enough to completely remove the conflict.
 129
 130                                         // For example, see two groups with conflicts:
 131                                         // userExpLevel: [
 132                                         //   {
 133                                         //     name: 'experienced',
 134                                         //     conflicts: [ 'unregistered' ]
 135                                         //   }
 136                                         // ],
 137                                         // registration: [
 138                                         //   {
 139                                         //     name: 'registered',
 140                                         //   },
 141                                         //   {
 142                                         //     name: 'unregistered',
 143                                         //   }
 144                                         // ]
 145                                         // If we select 'experienced', then 'unregistered' is in conflict (and vice versa),
 146                                         // because, inherently, 'experienced' filter only includes registered users, and so
 147                                         // both filters are in conflict with one another.
 148                                         // However, the minute we select 'registered', the scope of our results
 149                                         // has expanded to no longer have a conflict with 'experienced' filter, and
 150                                         // so the conflict is removed.
 151
 152                                         // In our case, we need to check if the entire group conflicts with
 153                                         // the entire item's group, so we follow the above spec
 154                                         inConflict = (
 155                                                 // The foreign group is in conflict with this item
 156                                                 groupModel.areAllSelectedInConflictWith( filterItem ) &&
 157                                                 // Every selected member of the item's own group is also
 158                                                 // in conflict with the other group
 159                                                 filterItemGroup.getSelectedItems().every( function ( otherGroupItem ) {
 160                                                         return groupModel.areAllSelectedInConflictWith( otherGroupItem );
 161                                                 } )
 162                                         );
 163                                 }
 164
 165                                 // If we're in conflict, this will return 'false' which
 166                                 // will break the loop. Otherwise, we're not in conflict
 167                                 // and the loop continues
 168                                 return !inConflict;
 169                         } );
 170
 171                         // Toggle the item state
 172                         filterItem.toggleConflicted( inConflict );
 173                 } );
 174         };
 175
 176         /**
 177          * Get whether the model has any conflict in its items
 178          *
 179          * @return {boolean} There is a conflict
 180          */
 181         mw.rcfilters.dm.FiltersViewModel.prototype.hasConflict = function () {
 182                 return this.getItems().some( function ( filterItem ) {
 183                         return filterItem.isSelected() && filterItem.isConflicted();
 184                 } );
 185         };
 186
 187         /**
 188          * Get the first item with a current conflict
 189          *
 190          * @return {mw.rcfilters.dm.FilterItem} Conflicted item
 191          */
 192         mw.rcfilters.dm.FiltersViewModel.prototype.getFirstConflictedItem = function () {
 193                 var conflictedItem;
 194
 195                 $.each( this.getItems(), function ( index, filterItem ) {
 196                         if ( filterItem.isSelected() && filterItem.isConflicted() ) {
 197                                 conflictedItem = filterItem;
 198                                 return false;
 199                         }
 200                 } );
 201
 202                 return conflictedItem;
 203         };
 204
 205         /**
 206          * Set filters and preserve a group relationship based on
 207          * the definition given by an object
 208          *
 209          * @param {Array} filterGroups Filters definition
 210          * @param {Object} [views] Extra views definition
 211          *  Expected in the following format:
 212          *  {
 213          *     namespaces: {
 214          *       label: 'namespaces', // Message key
 215          *       trigger: ':',
 216          *       groups: [
 217          *         {
 218          *            // Group info
 219          *            name: 'namespaces' // Parameter name
 220          *            title: 'namespaces' // Message key
 221          *            type: 'string_options',
 222          *            separator: ';',
 223          *            labelPrefixKey: { 'default': 'rcfilters-tag-prefix-namespace', inverted: 'rcfilters-tag-prefix-namespace-inverted' },
 224          *            fullCoverage: true
 225          *            items: []
 226          *         }
 227          *       ]
 228          *     }
 229          *  }
 230          */
 231         mw.rcfilters.dm.FiltersViewModel.prototype.initializeFilters = function ( filterGroups, views ) {
 232                 var filterConflictResult, groupConflictResult,
 233                         allViews = {},
 234                         model = this,
 235                         items = [],
 236                         groupConflictMap = {},
 237                         filterConflictMap = {},
 238                         /*!
 239                          * Expand a conflict definition from group name to
 240                          * the list of all included filters in that group.
 241                          * We do this so that the direct relationship in the
 242                          * models are consistently item->items rather than
 243                          * mixing item->group with item->item.
 244                          *
 245                          * @param {Object} obj Conflict definition
 246                          * @return {Object} Expanded conflict definition
 247                          */
 248                         expandConflictDefinitions = function ( obj ) {
 249                                 var result = {};
 250
 251                                 $.each( obj, function ( key, conflicts ) {
 252                                         var filterName,
 253                                                 adjustedConflicts = {};
 254
 255                                         conflicts.forEach( function ( conflict ) {
 256                                                 var filter;
 257
 258                                                 if ( conflict.filter ) {
 259                                                         filterName = model.groups[ conflict.group ].getPrefixedName( conflict.filter );
 260                                                         filter = model.getItemByName( filterName );
 261
 262                                                         // Rename
 263                                                         adjustedConflicts[ filterName ] = $.extend(
 264                                                                 {},
 265                                                                 conflict,
 266                                                                 {
 267                                                                         filter: filterName,
 268                                                                         item: filter
 269                                                                 }
 270                                                         );
 271                                                 } else {
 272                                                         // This conflict is for an entire group. Split it up to
 273                                                         // represent each filter
 274
 275                                                         // Get the relevant group items
 276                                                         model.groups[ conflict.group ].getItems().forEach( function ( groupItem ) {
 277                                                                 // Rebuild the conflict
 278                                                                 adjustedConflicts[ groupItem.getName() ] = $.extend(
 279                                                                         {},
 280                                                                         conflict,
 281                                                                         {
 282                                                                                 filter: groupItem.getName(),
 283                                                                                 item: groupItem
 284                                                                         }
 285                                                                 );
 286                                                         } );
 287                                                 }
 288                                         } );
 289
 290                                         result[ key ] = adjustedConflicts;
 291                                 } );
 292
 293                                 return result;
 294                         };
 295
 296                 // Reset
 297                 this.clearItems();
 298                 this.groups = {};
 299                 this.views = {};
 300
 301                 // Clone
 302                 filterGroups = OO.copy( filterGroups );
 303
 304                 // Normalize definition from the server
 305                 filterGroups.forEach( function ( data ) {
 306                         var i;
 307                         // What's this information needs to be normalized
 308                         data.whatsThis = {
 309                                 body: data.whatsThisBody,
 310                                 header: data.whatsThisHeader,
 311                                 linkText: data.whatsThisLinkText,
 312                                 url: data.whatsThisUrl
 313                         };
 314
 315                         // Title is a msg-key
 316                         data.title = data.title ? mw.msg( data.title ) : data.name;
 317
 318                         // Filters are given to us with msg-keys, we need
 319                         // to translate those before we hand them off
 320                         for ( i = 0; i < data.filters.length; i++ ) {
 321                                 data.filters[ i ].label = data.filters[ i ].label ? mw.msg( data.filters[ i ].label ) : data.filters[ i ].name;
 322                                 data.filters[ i ].description = data.filters[ i ].description ? mw.msg( data.filters[ i ].description ) : '';
 323                         }
 324                 } );
 325
 326                 // Collect views
 327                 allViews = $.extend( true, {
 328                         'default': {
 329                                 title: mw.msg( 'rcfilters-filterlist-title' ),
 330                                 groups: filterGroups
 331                         }
 332                 }, views );
 333
 334                 // Go over all views
 335                 $.each( allViews, function ( viewName, viewData ) {
 336                         // Define the view
 337                         model.views[ viewName ] = {
 338                                 name: viewData.name,
 339                                 title: viewData.title,
 340                                 trigger: viewData.trigger
 341                         };
 342
 343                         // Go over groups
 344                         viewData.groups.forEach( function ( groupData ) {
 345                                 var group = groupData.name;
 346
 347                                 if ( !model.groups[ group ] ) {
 348                                         model.groups[ group ] = new mw.rcfilters.dm.FilterGroup(
 349                                                 group,
 350                                                 $.extend( true, {}, groupData, { view: viewName } )
 351                                         );
 352                                 }
 353
 354                                 model.groups[ group ].initializeFilters( groupData.filters, groupData.default );
 355                                 items = items.concat( model.groups[ group ].getItems() );
 356
 357                                 // Prepare conflicts
 358                                 if ( groupData.conflicts ) {
 359                                         // Group conflicts
 360                                         groupConflictMap[ group ] = groupData.conflicts;
 361                                 }
 362
 363                                 groupData.filters.forEach( function ( itemData ) {
 364                                         var filterItem = model.groups[ group ].getItemByParamName( itemData.name );
 365                                         // Filter conflicts
 366                                         if ( itemData.conflicts ) {
 367                                                 filterConflictMap[ filterItem.getName() ] = itemData.conflicts;
 368                                         }
 369                                 } );
 370                         } );
 371                 } );
 372
 373                 // Add item references to the model, for lookup
 374                 this.addItems( items );
 375
 376                 // Expand conflicts
 377                 groupConflictResult = expandConflictDefinitions( groupConflictMap );
 378                 filterConflictResult = expandConflictDefinitions( filterConflictMap );
 379
 380                 // Set conflicts for groups
 381                 $.each( groupConflictResult, function ( group, conflicts ) {
 382                         model.groups[ group ].setConflicts( conflicts );
 383                 } );
 384
 385                 // Set conflicts for items
 386                 $.each( filterConflictResult, function ( filterName, conflicts ) {
 387                         var filterItem = model.getItemByName( filterName );
 388                         // set conflicts for items in the group
 389                         filterItem.setConflicts( conflicts );
 390                 } );
 391
 392                 // Create a map between known parameters and their models
 393                 $.each( this.groups, function ( group, groupModel ) {
 394                         if (
 395                                 groupModel.getType() === 'send_unselected_if_any' ||
 396                                 groupModel.getType() === 'boolean'
 397                         ) {
 398                                 // Individual filters
 399                                 groupModel.getItems().forEach( function ( filterItem ) {
 400                                         model.parameterMap[ filterItem.getParamName() ] = filterItem;
 401                                 } );
 402                         } else if (
 403                                 groupModel.getType() === 'string_options' ||
 404                                 groupModel.getType() === 'single_option'
 405                         ) {
 406                                 // Group
 407                                 model.parameterMap[ groupModel.getName() ] = groupModel;
 408                         }
 409                 } );
 410
 411                 this.currentView = 'default';
 412
 413                 // Finish initialization
 414                 this.emit( 'initialize' );
 415         };
 416
 417         /**
 418          * Get the names of all available filters
 419          *
 420          * @return {string[]} An array of filter names
 421          */
 422         mw.rcfilters.dm.FiltersViewModel.prototype.getFilterNames = function () {
 423                 return this.getItems().map( function ( item ) { return item.getName(); } );
 424         };
 425
 426         /**
 427          * Get the object that defines groups by their name.
 428          *
 429          * @return {Object} Filter groups
 430          */
 431         mw.rcfilters.dm.FiltersViewModel.prototype.getFilterGroups = function () {
 432                 return this.groups;
 433         };
 434
 435         /**
 436          * Get the object that defines groups that match a certain view by their name.
 437          *
 438          * @param {string} [view] Requested view. If not given, uses current view
 439          * @return {Object} Filter groups matching a display group
 440          */
 441         mw.rcfilters.dm.FiltersViewModel.prototype.getFilterGroupsByView = function ( view ) {
 442                 var result = {};
 443
 444                 view = view || this.getCurrentView();
 445
 446                 $.each( this.groups, function ( groupName, groupModel ) {
 447                         if ( groupModel.getView() === view ) {
 448                                 result[ groupName ] = groupModel;
 449                         }
 450                 } );
 451
 452                 return result;
 453         };
 454
 455         /**
 456          * Get an array of filters matching the given display group.
 457          *
 458          * @param {string} [view] Requested view. If not given, uses current view
 459          * @return {mw.rcfilters.dm.FilterItem} Filter items matching the group
 460          */
 461         mw.rcfilters.dm.FiltersViewModel.prototype.getFiltersByView = function ( view ) {
 462                 var groups,
 463                         result = [];
 464
 465                 view = view || this.getCurrentView();
 466
 467                 groups = this.getFilterGroupsByView( view );
 468
 469                 $.each( groups, function ( groupName, groupModel ) {
 470                         result = result.concat( groupModel.getItems() );
 471                 } );
 472
 473                 return result;
 474         };
 475
 476         /**
 477          * Get the trigger for the requested view.
 478          *
 479          * @param {string} view View name
 480          * @return {string} View trigger, if exists
 481          */
 482         mw.rcfilters.dm.FiltersViewModel.prototype.getViewTrigger = function ( view ) {
 483                 return ( this.views[ view ] && this.views[ view ].trigger ) || '';
 484         };
 485         /**
 486          * Get the value of a specific parameter
 487          *
 488          * @param {string} name Parameter name
 489          * @return {number|string} Parameter value
 490          */
 491         mw.rcfilters.dm.FiltersViewModel.prototype.getParamValue = function ( name ) {
 492                 return this.parameters[ name ];
 493         };
 494
 495         /**
 496          * Get the current selected state of the filters
 497          *
 498          * @return {Object} Filters selected state
 499          */
 500         mw.rcfilters.dm.FiltersViewModel.prototype.getSelectedState = function () {
 501                 var i,
 502                         items = this.getItems(),
 503                         result = {};
 504
 505                 for ( i = 0; i < items.length; i++ ) {
 506                         result[ items[ i ].getName() ] = items[ i ].isSelected();
 507                 }
 508
 509                 return result;
 510         };
 511
 512         /**
 513          * Get the current full state of the filters
 514          *
 515          * @return {Object} Filters full state
 516          */
 517         mw.rcfilters.dm.FiltersViewModel.prototype.getFullState = function () {
 518                 var i,
 519                         items = this.getItems(),
 520                         result = {};
 521
 522                 for ( i = 0; i < items.length; i++ ) {
 523                         result[ items[ i ].getName() ] = {
 524                                 selected: items[ i ].isSelected(),
 525                                 conflicted: items[ i ].isConflicted(),
 526                                 included: items[ i ].isIncluded()
 527                         };
 528                 }
 529
 530                 return result;
 531         };
 532
 533         /**
 534          * Get an object representing default parameters state
 535          *
 536          * @return {Object} Default parameter values
 537          */
 538         mw.rcfilters.dm.FiltersViewModel.prototype.getDefaultParams = function () {
 539                 var result = {};
 540
 541                 // Get default filter state
 542                 $.each( this.groups, function ( name, model ) {
 543                         $.extend( true, result, model.getDefaultParams() );
 544                 } );
 545
 546                 return result;
 547         };
 548
 549         /**
 550          * Get a parameter representation of all sticky parameters
 551          *
 552          * @return {Object} Sticky parameter values
 553          */
 554         mw.rcfilters.dm.FiltersViewModel.prototype.getStickyParams = function () {
 555                 var result = {};
 556
 557                 $.each( this.groups, function ( name, model ) {
 558                         if ( model.isSticky() ) {
 559                                 $.extend( true, result, model.getDefaultParams() );
 560                         }
 561                 } );
 562
 563                 return result;
 564         };
 565
 566         /**
 567          * Get a filter representation of all sticky parameters
 568          *
 569          * @return {Object} Sticky filters values
 570          */
 571         mw.rcfilters.dm.FiltersViewModel.prototype.getStickyFiltersState = function () {
 572                 var result = {};
 573
 574                 $.each( this.groups, function ( name, model ) {
 575                         if ( model.isSticky() ) {
 576                                 $.extend( true, result, model.getSelectedState() );
 577                         }
 578                 } );
 579
 580                 return result;
 581         };
 582
 583         /**
 584          * Get a filter representation of all parameters that are marked
 585          * as being excluded from saved query.
 586          *
 587          * @return {Object} Excluded filters values
 588          */
 589         mw.rcfilters.dm.FiltersViewModel.prototype.getExcludedFiltersState = function () {
 590                 var result = {};
 591
 592                 $.each( this.groups, function ( name, model ) {
 593                         if ( model.isExcludedFromSavedQueries() ) {
 594                                 $.extend( true, result, model.getSelectedState() );
 595                         }
 596                 } );
 597
 598                 return result;
 599         };
 600
 601         /**
 602          * Analyze the groups and their filters and output an object representing
 603          * the state of the parameters they represent.
 604          *
 605          * @param {Object} [filterDefinition] An object defining the filter values,
 606          *  keyed by filter names.
 607          * @return {Object} Parameter state object
 608          */
 609         mw.rcfilters.dm.FiltersViewModel.prototype.getParametersFromFilters = function ( filterDefinition ) {
 610                 var groupItemDefinition,
 611                         result = {},
 612                         groupItems = this.getFilterGroups();
 613
 614                 if ( filterDefinition ) {
 615                         groupItemDefinition = {};
 616                         // Filter definition is "flat", but in effect
 617                         // each group needs to tell us its result based
 618                         // on the values in it. We need to split this list
 619                         // back into groupings so we can "feed" it to the
 620                         // loop below, and we need to expand it so it includes
 621                         // all filters (set to false)
 622                         this.getItems().forEach( function ( filterItem ) {
 623                                 groupItemDefinition[ filterItem.getGroupName() ] = groupItemDefinition[ filterItem.getGroupName() ] || {};
 624                                 groupItemDefinition[ filterItem.getGroupName() ][ filterItem.getName() ] = !!filterDefinition[ filterItem.getName() ];
 625                         } );
 626                 }
 627
 628                 $.each( groupItems, function ( group, model ) {
 629                         $.extend(
 630                                 result,
 631                                 model.getParamRepresentation(
 632                                         groupItemDefinition ?
 633                                                 groupItemDefinition[ group ] : null
 634                                 )
 635                         );
 636                 } );
 637
 638                 return result;
 639         };
 640
 641         /**
 642          * This is the opposite of the #getParametersFromFilters method; this goes over
 643          * the given parameters and translates into a selected/unselected value in the filters.
 644          *
 645          * @param {Object} params Parameters query object
 646          * @return {Object} Filter state object
 647          */
 648         mw.rcfilters.dm.FiltersViewModel.prototype.getFiltersFromParameters = function ( params ) {
 649                 var groupMap = {},
 650                         model = this,
 651                         result = {};
 652
 653                 // Go over the given parameters, break apart to groupings
 654                 // The resulting object represents the group with its parameter
 655                 // values. For example:
 656                 // {
 657                 //    group1: {
 658                 //       param1: "1",
 659                 //       param2: "0",
 660                 //       param3: "1"
 661                 //    },
 662                 //    group2: "param4|param5"
 663                 // }
 664                 $.each( params, function ( paramName, paramValue ) {
 665                         var groupName,
 666                                 itemOrGroup = model.parameterMap[ paramName ];
 667
 668                         if ( itemOrGroup ) {
 669                                 groupName = itemOrGroup instanceof mw.rcfilters.dm.FilterItem ?
 670                                         itemOrGroup.getGroupName() : itemOrGroup.getName();
 671
 672                                 groupMap[ groupName ] = groupMap[ groupName ] || {};
 673                                 groupMap[ groupName ][ paramName ] = paramValue;
 674                         }
 675                 } );
 676
 677                 // Go over all groups, so we make sure we get the complete output
 678                 // even if the parameters don't include a certain group
 679                 $.each( this.groups, function ( groupName, groupModel ) {
 680                         result = $.extend( true, {}, result, groupModel.getFilterRepresentation( groupMap[ groupName ] ) );
 681                 } );
 682
 683                 return result;
 684         };
 685
 686         /**
 687          * Get the highlight parameters based on current filter configuration
 688          *
 689          * @return {Object} Object where keys are `<filter name>_color` and values
 690          *                  are the selected highlight colors.
 691          */
 692         mw.rcfilters.dm.FiltersViewModel.prototype.getHighlightParameters = function () {
 693                 var result = {};
 694
 695                 this.getItems().forEach( function ( filterItem ) {
 696                         result[ filterItem.getName() + '_color' ] = filterItem.getHighlightColor() || null;
 697                 } );
 698                 result.highlight = String( Number( this.isHighlightEnabled() ) );
 699
 700                 return result;
 701         };
 702
 703         /**
 704          * Extract the highlight values from given object. Since highlights are
 705          * the same for filter and parameters, it doesn't matter which one is
 706          * given; values will be returned with a full list of the highlights
 707          * with colors or null values.
 708          *
 709          * @param {Object} representation Object containing representation of
 710          *  some or all highlight values
 711          * @return {Object} Object where keys are `<filter name>_color` and values
 712          *                  are the selected highlight colors. The returned object
 713          *                  contains all available filters either with a color value
 714          *                  or with null.
 715          */
 716         mw.rcfilters.dm.FiltersViewModel.prototype.extractHighlightValues = function ( representation ) {
 717                 var result = {};
 718
 719                 this.getItems().forEach( function ( filterItem ) {
 720                         var highlightName = filterItem.getName() + '_color';
 721                         result[ highlightName ] = representation[ highlightName ] || null;
 722                 } );
 723
 724                 return result;
 725         };
 726
 727         /**
 728          * Sanitize value group of a string_option groups type
 729          * Remove duplicates and make sure to only use valid
 730          * values.
 731          *
 732          * @private
 733          * @param {string} groupName Group name
 734          * @param {string[]} valueArray Array of values
 735          * @return {string[]} Array of valid values
 736          */
 737         mw.rcfilters.dm.FiltersViewModel.prototype.sanitizeStringOptionGroup = function ( groupName, valueArray ) {
 738                 var validNames = this.getGroupFilters( groupName ).map( function ( filterItem ) {
 739                         return filterItem.getParamName();
 740                 } );
 741
 742                 return mw.rcfilters.utils.normalizeParamOptions( valueArray, validNames );
 743         };
 744
 745         /**
 746          * Check whether the current filter state is set to all false.
 747          *
 748          * @return {boolean} Current filters are all empty
 749          */
 750         mw.rcfilters.dm.FiltersViewModel.prototype.areCurrentFiltersEmpty = function () {
 751                 // Check if there are either any selected items or any items
 752                 // that have highlight enabled
 753                 return !this.getItems().some( function ( filterItem ) {
 754                         return !filterItem.getGroupModel().isHidden() && ( filterItem.isSelected() || filterItem.isHighlighted() );
 755                 } );
 756         };
 757
 758         /**
 759          * Check whether the default values of the filters are all false.
 760          *
 761          * @return {boolean} Default filters are all false
 762          */
 763         mw.rcfilters.dm.FiltersViewModel.prototype.areDefaultFiltersEmpty = function () {
 764                 var defaultFilters;
 765
 766                 if ( this.defaultFiltersEmpty !== null ) {
 767                         // We only need to do this test once,
 768                         // because defaults are set once per session
 769                         defaultFilters = this.getFiltersFromParameters( this.getDefaultParams() );
 770                         this.defaultFiltersEmpty = Object.keys( defaultFilters ).every( function ( filterName ) {
 771                                 return !defaultFilters[ filterName ];
 772                         } );
 773                 }
 774
 775                 return this.defaultFiltersEmpty;
 776         };
 777
 778         /**
 779          * Get the item that matches the given name
 780          *
 781          * @param {string} name Filter name
 782          * @return {mw.rcfilters.dm.FilterItem} Filter item
 783          */
 784         mw.rcfilters.dm.FiltersViewModel.prototype.getItemByName = function ( name ) {
 785                 return this.getItems().filter( function ( item ) {
 786                         return name === item.getName();
 787                 } )[ 0 ];
 788         };
 789
 790         /**
 791          * Set all filters to false or empty/all
 792          * This is equivalent to display all.
 793          */
 794         mw.rcfilters.dm.FiltersViewModel.prototype.emptyAllFilters = function () {
 795                 this.getItems().forEach( function ( filterItem ) {
 796                         this.toggleFilterSelected( filterItem.getName(), false );
 797                 }.bind( this ) );
 798         };
 799
 800         /**
 801          * Toggle selected state of one item
 802          *
 803          * @param {string} name Name of the filter item
 804          * @param {boolean} [isSelected] Filter selected state
 805          */
 806         mw.rcfilters.dm.FiltersViewModel.prototype.toggleFilterSelected = function ( name, isSelected ) {
 807                 var item = this.getItemByName( name );
 808
 809                 if ( item ) {
 810                         item.toggleSelected( isSelected );
 811                 }
 812         };
 813
 814         /**
 815          * Toggle selected state of items by their names
 816          *
 817          * @param {Object} filterDef Filter definitions
 818          */
 819         mw.rcfilters.dm.FiltersViewModel.prototype.toggleFiltersSelected = function ( filterDef ) {
 820                 Object.keys( filterDef ).forEach( function ( name ) {
 821                         this.toggleFilterSelected( name, filterDef[ name ] );
 822                 }.bind( this ) );
 823         };
 824
 825         /**
 826          * Get a group model from its name
 827          *
 828          * @param {string} groupName Group name
 829          * @return {mw.rcfilters.dm.FilterGroup} Group model
 830          */
 831         mw.rcfilters.dm.FiltersViewModel.prototype.getGroup = function ( groupName ) {
 832                 return this.groups[ groupName ];
 833         };
 834
 835         /**
 836          * Get all filters within a specified group by its name
 837          *
 838          * @param {string} groupName Group name
 839          * @return {mw.rcfilters.dm.FilterItem[]} Filters belonging to this group
 840          */
 841         mw.rcfilters.dm.FiltersViewModel.prototype.getGroupFilters = function ( groupName ) {
 842                 return ( this.getGroup( groupName ) && this.getGroup( groupName ).getItems() ) || [];
 843         };
 844
 845         /**
 846          * Find items whose labels match the given string
 847          *
 848          * @param {string} query Search string
 849          * @param {boolean} [returnFlat] Return a flat array. If false, the result
 850          *  is an object whose keys are the group names and values are an array of
 851          *  filters per group. If set to true, returns an array of filters regardless
 852          *  of their groups.
 853          * @return {Object} An object of items to show
 854          *  arranged by their group names
 855          */
 856         mw.rcfilters.dm.FiltersViewModel.prototype.findMatches = function ( query, returnFlat ) {
 857                 var i, searchIsEmpty,
 858                         groupTitle,
 859                         result = {},
 860                         flatResult = [],
 861                         view = this.getViewByTrigger( query.substr( 0, 1 ) ),
 862                         items = this.getFiltersByView( view );
 863
 864                 // Normalize so we can search strings regardless of case and view
 865                 query = query.trim().toLowerCase();
 866                 if ( view !== 'default' ) {
 867                         query = query.substr( 1 );
 868                 }
 869                 // Trim again to also intercept cases where the spaces were after the trigger
 870                 // eg: '#   str'
 871                 query = query.trim();
 872
 873                 // Check if the search if actually empty; this can be a problem when
 874                 // we use prefixes to denote different views
 875                 searchIsEmpty = query.length === 0;
 876
 877                 // item label starting with the query string
 878                 for ( i = 0; i < items.length; i++ ) {
 879                         if (
 880                                 searchIsEmpty ||
 881                                 items[ i ].getLabel().toLowerCase().indexOf( query ) === 0 ||
 882                                 (
 883                                         // For tags, we want the parameter name to be included in the search
 884                                         view === 'tags' &&
 885                                         items[ i ].getParamName().toLowerCase().indexOf( query ) > -1
 886                                 )
 887                         ) {
 888                                 result[ items[ i ].getGroupName() ] = result[ items[ i ].getGroupName() ] || [];
 889                                 result[ items[ i ].getGroupName() ].push( items[ i ] );
 890                                 flatResult.push( items[ i ] );
 891                         }
 892                 }
 893
 894                 if ( $.isEmptyObject( result ) ) {
 895                         // item containing the query string in their label, description, or group title
 896                         for ( i = 0; i < items.length; i++ ) {
 897                                 groupTitle = items[ i ].getGroupModel().getTitle();
 898                                 if (
 899                                         searchIsEmpty ||
 900                                         items[ i ].getLabel().toLowerCase().indexOf( query ) > -1 ||
 901                                         items[ i ].getDescription().toLowerCase().indexOf( query ) > -1 ||
 902                                         groupTitle.toLowerCase().indexOf( query ) > -1 ||
 903                                         (
 904                                                 // For tags, we want the parameter name to be included in the search
 905                                                 view === 'tags' &&
 906                                                 items[ i ].getParamName().toLowerCase().indexOf( query ) > -1
 907                                         )
 908                                 ) {
 909                                         result[ items[ i ].getGroupName() ] = result[ items[ i ].getGroupName() ] || [];
 910                                         result[ items[ i ].getGroupName() ].push( items[ i ] );
 911                                         flatResult.push( items[ i ] );
 912                                 }
 913                         }
 914                 }
 915
 916                 return returnFlat ? flatResult : result;
 917         };
 918
 919         /**
 920          * Get items that are highlighted
 921          *
 922          * @return {mw.rcfilters.dm.FilterItem[]} Highlighted items
 923          */
 924         mw.rcfilters.dm.FiltersViewModel.prototype.getHighlightedItems = function () {
 925                 return this.getItems().filter( function ( filterItem ) {
 926                         return filterItem.isHighlightSupported() &&
 927                                 filterItem.getHighlightColor();
 928                 } );
 929         };
 930
 931         /**
 932          * Get items that allow highlights even if they're not currently highlighted
 933          *
 934          * @return {mw.rcfilters.dm.FilterItem[]} Items supporting highlights
 935          */
 936         mw.rcfilters.dm.FiltersViewModel.prototype.getItemsSupportingHighlights = function () {
 937                 return this.getItems().filter( function ( filterItem ) {
 938                         return filterItem.isHighlightSupported();
 939                 } );
 940         };
 941
 942         /**
 943          * Get all selected items
 944          *
 945          * @return {mw.rcfilters.dm.FilterItem[]} Selected items
 946          */
 947         mw.rcfilters.dm.FiltersViewModel.prototype.getSelectedItems = function () {
 948                 var allSelected = [];
 949
 950                 $.each( this.getFilterGroups(), function ( groupName, groupModel ) {
 951                         allSelected = allSelected.concat( groupModel.getSelectedItems() );
 952                 } );
 953
 954                 return allSelected;
 955         };
 956         /**
 957          * Switch the current view
 958          *
 959          * @param {string} view View name
 960          * @fires update
 961          */
 962         mw.rcfilters.dm.FiltersViewModel.prototype.switchView = function ( view ) {
 963                 if ( this.views[ view ] && this.currentView !== view ) {
 964                         this.currentView = view;
 965                         this.emit( 'update' );
 966                 }
 967         };
 968
 969         /**
 970          * Get the current view
 971          *
 972          * @return {string} Current view
 973          */
 974         mw.rcfilters.dm.FiltersViewModel.prototype.getCurrentView = function () {
 975                 return this.currentView;
 976         };
 977
 978         /**
 979          * Get the label for the current view
 980          *
 981          * @param {string} viewName View name
 982          * @return {string} Label for the current view
 983          */
 984         mw.rcfilters.dm.FiltersViewModel.prototype.getViewTitle = function ( viewName ) {
 985                 viewName = viewName || this.getCurrentView();
 986
 987                 return this.views[ viewName ] && this.views[ viewName ].title;
 988         };
 989
 990         /**
 991          * Get an array of all available view names
 992          *
 993          * @return {string} Available view names
 994          */
 995         mw.rcfilters.dm.FiltersViewModel.prototype.getAvailableViews = function () {
 996                 return Object.keys( this.views );
 997         };
 998
 999         /**
1000          * Get the view that fits the given trigger
1001          *
1002          * @param {string} trigger Trigger
1003          * @return {string} Name of view
1004          */
1005         mw.rcfilters.dm.FiltersViewModel.prototype.getViewByTrigger = function ( trigger ) {
1006                 var result = 'default';
1007
1008                 $.each( this.views, function ( name, data ) {
1009                         if ( data.trigger === trigger ) {
1010                                 result = name;
1011                         }
1012                 } );
1013
1014                 return result;
1015         };
1016
1017         /**
1018          * Toggle the highlight feature on and off.
1019          * Propagate the change to filter items.
1020          *
1021          * @param {boolean} enable Highlight should be enabled
1022          * @fires highlightChange
1023          */
1024         mw.rcfilters.dm.FiltersViewModel.prototype.toggleHighlight = function ( enable ) {
1025                 enable = enable === undefined ? !this.highlightEnabled : enable;
1026
1027                 if ( this.highlightEnabled !== enable ) {
1028                         this.highlightEnabled = enable;
1029
1030                         this.getItems().forEach( function ( filterItem ) {
1031                                 filterItem.toggleHighlight( this.highlightEnabled );
1032                         }.bind( this ) );
1033
1034                         this.emit( 'highlightChange', this.highlightEnabled );
1035                 }
1036         };
1037
1038         /**
1039          * Check if the highlight feature is enabled
1040          * @return {boolean}
1041          */
1042         mw.rcfilters.dm.FiltersViewModel.prototype.isHighlightEnabled = function () {
1043                 return !!this.highlightEnabled;
1044         };
1045
1046         /**
1047          * Toggle the inverted namespaces property on and off.
1048          * Propagate the change to namespace filter items.
1049          *
1050          * @param {boolean} enable Inverted property is enabled
1051          * @fires invertChange
1052          */
1053         mw.rcfilters.dm.FiltersViewModel.prototype.toggleInvertedNamespaces = function ( enable ) {
1054                 enable = enable === undefined ? !this.invertedNamespaces : enable;
1055
1056                 if ( this.invertedNamespaces !== enable ) {
1057                         this.invertedNamespaces = enable;
1058
1059                         this.getFiltersByView( 'namespaces' ).forEach( function ( filterItem ) {
1060                                 filterItem.toggleInverted( this.invertedNamespaces );
1061                         }.bind( this ) );
1062
1063                         this.emit( 'invertChange', this.invertedNamespaces );
1064                 }
1065         };
1066
1067         /**
1068          * Check if the namespaces selection is set to be inverted
1069          * @return {boolean}
1070          */
1071         mw.rcfilters.dm.FiltersViewModel.prototype.areNamespacesInverted = function () {
1072                 return !!this.invertedNamespaces;
1073         };
1074
1075         /**
1076          * Set highlight color for a specific filter item
1077          *
1078          * @param {string} filterName Name of the filter item
1079          * @param {string} color Selected color
1080          */
1081         mw.rcfilters.dm.FiltersViewModel.prototype.setHighlightColor = function ( filterName, color ) {
1082                 this.getItemByName( filterName ).setHighlightColor( color );
1083         };
1084
1085         /**
1086          * Clear highlight for a specific filter item
1087          *
1088          * @param {string} filterName Name of the filter item
1089          */
1090         mw.rcfilters.dm.FiltersViewModel.prototype.clearHighlightColor = function ( filterName ) {
1091                 this.getItemByName( filterName ).clearHighlightColor();
1092         };
1093
1094         /**
1095          * Clear highlight for all filter items
1096          */
1097         mw.rcfilters.dm.FiltersViewModel.prototype.clearAllHighlightColors = function () {
1098                 this.getItems().forEach( function ( filterItem ) {
1099                         filterItem.clearHighlightColor();
1100                 } );
1101         };
1102
1103         /**
1104          * Return a version of the given string that is without any
1105          * view triggers.
1106          *
1107          * @param {string} str Given string
1108          * @return {string} Result
1109          */
1110         mw.rcfilters.dm.FiltersViewModel.prototype.removeViewTriggers = function ( str ) {
1111                 if ( this.getViewByTrigger( str.substr( 0, 1 ) ) !== 'default' ) {
1112                         str = str.substr( 1 );
1113                 }
1114
1115                 return str;
1116         };
1117 }( mediaWiki, jQuery ) );