dépôts / lhc / web / wiklou.git / blob
? search:


3b882a6ba7cbde5351a22394c75b08843b78b0f3
[lhc/web/wiklou.git] / 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 * Get an array of currently applied highlight colors
729 *
730 * @return {string[]} Currently applied highlight colors
731 */
732 mw.rcfilters.dm.FiltersViewModel.prototype.getCurrentlyUsedHighlightColors = function () {
733 var result = [];
734
735 this.getHighlightedItems().forEach( function ( filterItem ) {
736 var color = filterItem.getHighlightColor();
737
738 if ( result.indexOf( color ) === -1 ) {
739 result.push( color );
740 }
741 } );
742
743 return result;
744 };
745
746 /**
747 * Sanitize value group of a string_option groups type
748 * Remove duplicates and make sure to only use valid
749 * values.
750 *
751 * @private
752 * @param {string} groupName Group name
753 * @param {string[]} valueArray Array of values
754 * @return {string[]} Array of valid values
755 */
756 mw.rcfilters.dm.FiltersViewModel.prototype.sanitizeStringOptionGroup = function ( groupName, valueArray ) {
757 var validNames = this.getGroupFilters( groupName ).map( function ( filterItem ) {
758 return filterItem.getParamName();
759 } );
760
761 return mw.rcfilters.utils.normalizeParamOptions( valueArray, validNames );
762 };
763
764 /**
765 * Check whether the current filter state is set to all false.
766 *
767 * @return {boolean} Current filters are all empty
768 */
769 mw.rcfilters.dm.FiltersViewModel.prototype.areCurrentFiltersEmpty = function () {
770 // Check if there are either any selected items or any items
771 // that have highlight enabled
772 return !this.getItems().some( function ( filterItem ) {
773 return !filterItem.getGroupModel().isHidden() && ( filterItem.isSelected() || filterItem.isHighlighted() );
774 } );
775 };
776
777 /**
778 * Get the item that matches the given name
779 *
780 * @param {string} name Filter name
781 * @return {mw.rcfilters.dm.FilterItem} Filter item
782 */
783 mw.rcfilters.dm.FiltersViewModel.prototype.getItemByName = function ( name ) {
784 return this.getItems().filter( function ( item ) {
785 return name === item.getName();
786 } )[ 0 ];
787 };
788
789 /**
790 * Set all filters to false or empty/all
791 * This is equivalent to display all.
792 */
793 mw.rcfilters.dm.FiltersViewModel.prototype.emptyAllFilters = function () {
794 this.getItems().forEach( function ( filterItem ) {
795 if ( !filterItem.getGroupModel().isSticky() ) {
796 this.toggleFilterSelected( filterItem.getName(), false );
797 }
798 }.bind( this ) );
799 };
800
801 /**
802 * Toggle selected state of one item
803 *
804 * @param {string} name Name of the filter item
805 * @param {boolean} [isSelected] Filter selected state
806 */
807 mw.rcfilters.dm.FiltersViewModel.prototype.toggleFilterSelected = function ( name, isSelected ) {
808 var item = this.getItemByName( name );
809
810 if ( item ) {
811 item.toggleSelected( isSelected );
812 }
813 };
814
815 /**
816 * Toggle selected state of items by their names
817 *
818 * @param {Object} filterDef Filter definitions
819 */
820 mw.rcfilters.dm.FiltersViewModel.prototype.toggleFiltersSelected = function ( filterDef ) {
821 Object.keys( filterDef ).forEach( function ( name ) {
822 this.toggleFilterSelected( name, filterDef[ name ] );
823 }.bind( this ) );
824 };
825
826 /**
827 * Get a group model from its name
828 *
829 * @param {string} groupName Group name
830 * @return {mw.rcfilters.dm.FilterGroup} Group model
831 */
832 mw.rcfilters.dm.FiltersViewModel.prototype.getGroup = function ( groupName ) {
833 return this.groups[ groupName ];
834 };
835
836 /**
837 * Get all filters within a specified group by its name
838 *
839 * @param {string} groupName Group name
840 * @return {mw.rcfilters.dm.FilterItem[]} Filters belonging to this group
841 */
842 mw.rcfilters.dm.FiltersViewModel.prototype.getGroupFilters = function ( groupName ) {
843 return ( this.getGroup( groupName ) && this.getGroup( groupName ).getItems() ) || [];
844 };
845
846 /**
847 * Find items whose labels match the given string
848 *
849 * @param {string} query Search string
850 * @param {boolean} [returnFlat] Return a flat array. If false, the result
851 * is an object whose keys are the group names and values are an array of
852 * filters per group. If set to true, returns an array of filters regardless
853 * of their groups.
854 * @return {Object} An object of items to show
855 * arranged by their group names
856 */
857 mw.rcfilters.dm.FiltersViewModel.prototype.findMatches = function ( query, returnFlat ) {
858 var i, searchIsEmpty,
859 groupTitle,
860 result = {},
861 flatResult = [],
862 view = this.getViewByTrigger( query.substr( 0, 1 ) ),
863 items = this.getFiltersByView( view );
864
865 // Normalize so we can search strings regardless of case and view
866 query = query.trim().toLowerCase();
867 if ( view !== 'default' ) {
868 query = query.substr( 1 );
869 }
870 // Trim again to also intercept cases where the spaces were after the trigger
871 // eg: '# str'
872 query = query.trim();
873
874 // Check if the search if actually empty; this can be a problem when
875 // we use prefixes to denote different views
876 searchIsEmpty = query.length === 0;
877
878 // item label starting with the query string
879 for ( i = 0; i < items.length; i++ ) {
880 if (
881 searchIsEmpty ||
882 items[ i ].getLabel().toLowerCase().indexOf( query ) === 0 ||
883 (
884 // For tags, we want the parameter name to be included in the search
885 view === 'tags' &&
886 items[ i ].getParamName().toLowerCase().indexOf( query ) > -1
887 )
888 ) {
889 result[ items[ i ].getGroupName() ] = result[ items[ i ].getGroupName() ] || [];
890 result[ items[ i ].getGroupName() ].push( items[ i ] );
891 flatResult.push( items[ i ] );
892 }
893 }
894
895 if ( $.isEmptyObject( result ) ) {
896 // item containing the query string in their label, description, or group title
897 for ( i = 0; i < items.length; i++ ) {
898 groupTitle = items[ i ].getGroupModel().getTitle();
899 if (
900 searchIsEmpty ||
901 items[ i ].getLabel().toLowerCase().indexOf( query ) > -1 ||
902 items[ i ].getDescription().toLowerCase().indexOf( query ) > -1 ||
903 groupTitle.toLowerCase().indexOf( query ) > -1 ||
904 (
905 // For tags, we want the parameter name to be included in the search
906 view === 'tags' &&
907 items[ i ].getParamName().toLowerCase().indexOf( query ) > -1
908 )
909 ) {
910 result[ items[ i ].getGroupName() ] = result[ items[ i ].getGroupName() ] || [];
911 result[ items[ i ].getGroupName() ].push( items[ i ] );
912 flatResult.push( items[ i ] );
913 }
914 }
915 }
916
917 return returnFlat ? flatResult : result;
918 };
919
920 /**
921 * Get items that are highlighted
922 *
923 * @return {mw.rcfilters.dm.FilterItem[]} Highlighted items
924 */
925 mw.rcfilters.dm.FiltersViewModel.prototype.getHighlightedItems = function () {
926 return this.getItems().filter( function ( filterItem ) {
927 return filterItem.isHighlightSupported() &&
928 filterItem.getHighlightColor();
929 } );
930 };
931
932 /**
933 * Get items that allow highlights even if they're not currently highlighted
934 *
935 * @return {mw.rcfilters.dm.FilterItem[]} Items supporting highlights
936 */
937 mw.rcfilters.dm.FiltersViewModel.prototype.getItemsSupportingHighlights = function () {
938 return this.getItems().filter( function ( filterItem ) {
939 return filterItem.isHighlightSupported();
940 } );
941 };
942
943 /**
944 * Get all selected items
945 *
946 * @return {mw.rcfilters.dm.FilterItem[]} Selected items
947 */
948 mw.rcfilters.dm.FiltersViewModel.prototype.getSelectedItems = function () {
949 var allSelected = [];
950
951 $.each( this.getFilterGroups(), function ( groupName, groupModel ) {
952 allSelected = allSelected.concat( groupModel.getSelectedItems() );
953 } );
954
955 return allSelected;
956 };
957 /**
958 * Switch the current view
959 *
960 * @param {string} view View name
961 * @fires update
962 */
963 mw.rcfilters.dm.FiltersViewModel.prototype.switchView = function ( view ) {
964 if ( this.views[ view ] && this.currentView !== view ) {
965 this.currentView = view;
966 this.emit( 'update' );
967 }
968 };
969
970 /**
971 * Get the current view
972 *
973 * @return {string} Current view
974 */
975 mw.rcfilters.dm.FiltersViewModel.prototype.getCurrentView = function () {
976 return this.currentView;
977 };
978
979 /**
980 * Get the label for the current view
981 *
982 * @param {string} viewName View name
983 * @return {string} Label for the current view
984 */
985 mw.rcfilters.dm.FiltersViewModel.prototype.getViewTitle = function ( viewName ) {
986 viewName = viewName || this.getCurrentView();
987
988 return this.views[ viewName ] && this.views[ viewName ].title;
989 };
990
991 /**
992 * Get an array of all available view names
993 *
994 * @return {string} Available view names
995 */
996 mw.rcfilters.dm.FiltersViewModel.prototype.getAvailableViews = function () {
997 return Object.keys( this.views );
998 };
999
1000 /**
1001 * Get the view that fits the given trigger
1002 *
1003 * @param {string} trigger Trigger
1004 * @return {string} Name of view
1005 */
1006 mw.rcfilters.dm.FiltersViewModel.prototype.getViewByTrigger = function ( trigger ) {
1007 var result = 'default';
1008
1009 $.each( this.views, function ( name, data ) {
1010 if ( data.trigger === trigger ) {
1011 result = name;
1012 }
1013 } );
1014
1015 return result;
1016 };
1017
1018 /**
1019 * Toggle the highlight feature on and off.
1020 * Propagate the change to filter items.
1021 *
1022 * @param {boolean} enable Highlight should be enabled
1023 * @fires highlightChange
1024 */
1025 mw.rcfilters.dm.FiltersViewModel.prototype.toggleHighlight = function ( enable ) {
1026 enable = enable === undefined ? !this.highlightEnabled : enable;
1027
1028 if ( this.highlightEnabled !== enable ) {
1029 this.highlightEnabled = enable;
1030
1031 this.getItems().forEach( function ( filterItem ) {
1032 filterItem.toggleHighlight( this.highlightEnabled );
1033 }.bind( this ) );
1034
1035 this.emit( 'highlightChange', this.highlightEnabled );
1036 }
1037 };
1038
1039 /**
1040 * Check if the highlight feature is enabled
1041 * @return {boolean}
1042 */
1043 mw.rcfilters.dm.FiltersViewModel.prototype.isHighlightEnabled = function () {
1044 return !!this.highlightEnabled;
1045 };
1046
1047 /**
1048 * Toggle the inverted namespaces property on and off.
1049 * Propagate the change to namespace filter items.
1050 *
1051 * @param {boolean} enable Inverted property is enabled
1052 * @fires invertChange
1053 */
1054 mw.rcfilters.dm.FiltersViewModel.prototype.toggleInvertedNamespaces = function ( enable ) {
1055 enable = enable === undefined ? !this.invertedNamespaces : enable;
1056
1057 if ( this.invertedNamespaces !== enable ) {
1058 this.invertedNamespaces = enable;
1059
1060 this.getFiltersByView( 'namespaces' ).forEach( function ( filterItem ) {
1061 filterItem.toggleInverted( this.invertedNamespaces );
1062 }.bind( this ) );
1063
1064 this.emit( 'invertChange', this.invertedNamespaces );
1065 }
1066 };
1067
1068 /**
1069 * Check if the namespaces selection is set to be inverted
1070 * @return {boolean}
1071 */
1072 mw.rcfilters.dm.FiltersViewModel.prototype.areNamespacesInverted = function () {
1073 return !!this.invertedNamespaces;
1074 };
1075
1076 /**
1077 * Set highlight color for a specific filter item
1078 *
1079 * @param {string} filterName Name of the filter item
1080 * @param {string} color Selected color
1081 */
1082 mw.rcfilters.dm.FiltersViewModel.prototype.setHighlightColor = function ( filterName, color ) {
1083 this.getItemByName( filterName ).setHighlightColor( color );
1084 };
1085
1086 /**
1087 * Clear highlight for a specific filter item
1088 *
1089 * @param {string} filterName Name of the filter item
1090 */
1091 mw.rcfilters.dm.FiltersViewModel.prototype.clearHighlightColor = function ( filterName ) {
1092 this.getItemByName( filterName ).clearHighlightColor();
1093 };
1094
1095 /**
1096 * Clear highlight for all filter items
1097 */
1098 mw.rcfilters.dm.FiltersViewModel.prototype.clearAllHighlightColors = function () {
1099 this.getItems().forEach( function ( filterItem ) {
1100 filterItem.clearHighlightColor();
1101 } );
1102 };
1103
1104 /**
1105 * Return a version of the given string that is without any
1106 * view triggers.
1107 *
1108 * @param {string} str Given string
1109 * @return {string} Result
1110 */
1111 mw.rcfilters.dm.FiltersViewModel.prototype.removeViewTriggers = function ( str ) {
1112 if ( this.getViewByTrigger( str.substr( 0, 1 ) ) !== 'default' ) {
1113 str = str.substr( 1 );
1114 }
1115
1116 return str;
1117 };
1118 }( mediaWiki, jQuery ) );
Wiklou, le Wiki du Wiklou