2018-03-18 13:49:07 +00:00
/*! tablesorter (FORK) - updated 2018-03-18 (v2.30.0)*/
2015-03-28 20:03:50 +00:00
/* Includes widgets ( storage,uitheme,columns,filter,stickyHeaders,resizable,saveSort ) */
( function ( factory ) {
if ( typeof define === 'function' && define . amd ) {
define ( [ 'jquery' ] , factory ) ;
} else if ( typeof module === 'object' && typeof module . exports === 'object' ) {
module . exports = factory ( require ( 'jquery' ) ) ;
} else {
factory ( jQuery ) ;
}
2016-08-01 01:48:27 +00:00
} ( function ( jQuery ) {
2015-03-28 20:03:50 +00:00
2018-03-18 13:49:07 +00:00
/*! TableSorter (FORK) v2.30.0 */ / *
2015-03-28 20:03:50 +00:00
* Client - side table sorting with ease !
* @ requires jQuery v1 . 2.6 +
*
* Copyright ( c ) 2007 Christian Bach
* fork maintained by Rob Garrison
*
2016-08-01 01:48:27 +00:00
* Examples and original docs at : http : //tablesorter.com
2015-03-28 20:03:50 +00:00
* Dual licensed under the MIT and GPL licenses :
* http : //www.opensource.org/licenses/mit-license.php
* http : //www.gnu.org/licenses/gpl.html
*
* @ type jQuery
* @ name tablesorter ( FORK )
* @ cat Plugins / Tablesorter
* @ author Christian Bach - christian . bach @ polyester . se
* @ contributor Rob Garrison - https : //github.com/Mottie/tablesorter
2016-08-01 01:48:27 +00:00
* @ docs ( fork ) - https : //mottie.github.io/tablesorter/docs/
2015-03-28 20:03:50 +00:00
* /
/*jshint browser:true, jquery:true, unused:false, expr: true */
2015-10-18 18:21:11 +00:00
; ( function ( $ ) {
2015-03-28 20:03:50 +00:00
'use strict' ;
2015-10-18 18:21:11 +00:00
var ts = $ . tablesorter = {
2018-03-18 13:49:07 +00:00
version : '2.30.0' ,
2015-10-18 18:21:11 +00:00
parsers : [ ] ,
widgets : [ ] ,
defaults : {
// *** appearance
theme : 'default' , // adds tablesorter-{theme} to the table for styling
widthFixed : false , // adds colgroup to fix widths of columns
showProcessing : false , // show an indeterminate timer icon in the header when the table is sorted or filtered.
headerTemplate : '{content}' , // header layout template (HTML ok); {content} = innerHTML, {icon} = <i/> // class from cssIcon
2018-03-18 13:49:07 +00:00
onRenderTemplate : null , // function( index, template ) { return template; }, // template is a string
onRenderHeader : null , // function( index ) {}, // nothing to return
2015-10-18 18:21:11 +00:00
// *** functionality
cancelSelection : true , // prevent text selection in the header
tabIndex : true , // add tabindex to header for keyboard accessibility
dateFormat : 'mmddyyyy' , // other options: 'ddmmyyy' or 'yyyymmdd'
sortMultiSortKey : 'shiftKey' , // key used to select additional columns
sortResetKey : 'ctrlKey' , // key used to remove sorting on a column
usNumberFormat : true , // false for German '1.234.567,89' or French '1 234 567,89'
delayInit : false , // if false, the parsed table contents will not update until the first sort
serverSideSorting : false , // if true, server-side sorting should be performed because client-side sorting will be disabled, but the ui and events will still be used.
resort : true , // default setting to trigger a resort after an 'update', 'addRows', 'updateCell', etc has completed
// *** sort options
headers : { } , // set sorter, string, empty, locked order, sortInitialOrder, filter, etc.
ignoreCase : true , // ignore case while sorting
sortForce : null , // column(s) first sorted; always applied
sortList : [ ] , // Initial sort order; applied initially; updated when manually sorted
sortAppend : null , // column(s) sorted last; always applied
sortStable : false , // when sorting two rows with exactly the same content, the original sort order is maintained
sortInitialOrder : 'asc' , // sort direction on first click
sortLocaleCompare : false , // replace equivalent character (accented characters)
sortReset : false , // third click on the header will reset column to default - unsorted
sortRestart : false , // restart sort to 'sortInitialOrder' when clicking on previously unsorted columns
emptyTo : 'bottom' , // sort empty cell to bottom, top, none, zero, emptyMax, emptyMin
stringTo : 'max' , // sort strings in numerical column as max, min, top, bottom, zero
2015-12-13 22:24:42 +00:00
duplicateSpan : true , // colspan cells in the tbody will have duplicated content in the cache for each spanned column
2018-03-18 13:49:07 +00:00
textExtraction : 'basic' , // text extraction method/function - function( node, table, cellIndex ) {}
2015-10-18 18:21:11 +00:00
textAttribute : 'data-text' , // data-attribute that contains alternate cell text (used in default textExtraction function)
textSorter : null , // choose overall or specific column sorter function( a, b, direction, table, columnIndex ) [alt: ts.sortText]
numberSorter : null , // choose overall numeric sorter function( a, b, direction, maxColumnValue )
// *** widget options
2016-05-17 00:09:45 +00:00
initWidgets : true , // apply widgets on tablesorter initialization
widgetClass : 'widget-{name}' , // table class name template to match to include a widget
widgets : [ ] , // method to add widgets, e.g. widgets: ['zebra']
2015-10-18 18:21:11 +00:00
widgetOptions : {
2016-09-29 02:12:04 +00:00
zebra : [ 'even' , 'odd' ] // zebra widget alternating row class names
2015-10-18 18:21:11 +00:00
} ,
// *** callbacks
2018-03-18 13:49:07 +00:00
initialized : null , // function( table ) {},
2015-10-18 18:21:11 +00:00
// *** extra css class names
tableClass : '' ,
cssAsc : '' ,
cssDesc : '' ,
cssNone : '' ,
cssHeader : '' ,
cssHeaderRow : '' ,
cssProcessing : '' , // processing icon applied to header during sort/filter
2016-05-17 00:09:45 +00:00
cssChildRow : 'tablesorter-childRow' , // class name indiciating that a row is to be attached to its parent
2015-10-18 18:21:11 +00:00
cssInfoBlock : 'tablesorter-infoOnly' , // don't sort tbody with this class name (only one class name allowed here!)
2016-09-29 02:12:04 +00:00
cssNoSort : 'tablesorter-noSort' , // class name added to element inside header; clicking on it won't cause a sort
cssIgnoreRow : 'tablesorter-ignoreRow' , // header row to ignore; cells within this row will not be added to c.$headers
2015-10-18 18:21:11 +00:00
cssIcon : 'tablesorter-icon' , // if this class does not exist, the {icon} will not be added from the headerTemplate
cssIconNone : '' , // class name added to the icon when there is no column sort
cssIconAsc : '' , // class name added to the icon when the column has an ascending sort
cssIconDesc : '' , // class name added to the icon when the column has a descending sort
2017-06-02 22:49:41 +00:00
cssIconDisabled : '' , // class name added to the icon when the column has a disabled sort
2015-10-18 18:21:11 +00:00
// *** events
pointerClick : 'click' ,
pointerDown : 'mousedown' ,
pointerUp : 'mouseup' ,
// *** selectors
selectorHeaders : '> thead th, > thead td' ,
2016-09-29 02:12:04 +00:00
selectorSort : 'th, td' , // jQuery selector of content within selectorHeaders that is clickable to trigger a sort
2015-10-18 18:21:11 +00:00
selectorRemove : '.remove-me' ,
// *** advanced
debug : false ,
// *** Internal variables
headerList : [ ] ,
empties : { } ,
strings : { } ,
2016-11-27 01:40:00 +00:00
parsers : [ ] ,
// *** parser options for validator; values must be falsy!
globalize : 0 ,
imgAttr : 0
2015-10-18 18:21:11 +00:00
// removed: widgetZebra: { css: ['even', 'odd'] }
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
// internal css classes - these will ALWAYS be added to
// the table and MUST only contain one class name - fixes #381
css : {
table : 'tablesorter' ,
cssHasChild : 'tablesorter-hasChildRow' ,
childRow : 'tablesorter-childRow' ,
colgroup : 'tablesorter-colgroup' ,
header : 'tablesorter-header' ,
headerRow : 'tablesorter-headerRow' ,
headerIn : 'tablesorter-header-inner' ,
icon : 'tablesorter-icon' ,
processing : 'tablesorter-processing' ,
sortAsc : 'tablesorter-headerAsc' ,
sortDesc : 'tablesorter-headerDesc' ,
sortNone : 'tablesorter-headerUnSorted'
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
// labels applied to sortable headers for accessibility (aria) support
language : {
2015-11-10 21:27:30 +00:00
sortAsc : 'Ascending sort applied, ' ,
sortDesc : 'Descending sort applied, ' ,
sortNone : 'No sort applied, ' ,
sortDisabled : 'sorting is disabled' ,
nextAsc : 'activate to apply an ascending sort' ,
nextDesc : 'activate to apply a descending sort' ,
nextNone : 'activate to remove the sort'
2015-10-18 18:21:11 +00:00
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
regex : {
templateContent : /\{content\}/g ,
templateIcon : /\{icon\}/g ,
templateName : /\{name\}/i ,
spaces : /\s+/g ,
nonWord : /\W/g ,
formElements : /(input|select|button|textarea)/i ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
// *** sort functions ***
// regex used in natural sort
// chunk/tokenize numbers & letters
chunk : /(^([+\-]?(?:\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?)?$|^0x[0-9a-f]+$|\d+)/gi ,
// replace chunks @ ends
chunks : /(^\\0|\\0$)/ ,
hex : /^0x[0-9a-f]+$/i ,
// *** formatFloat ***
comma : /,/g ,
digitNonUS : /[\s|\.]/g ,
digitNegativeTest : /^\s*\([.\d]+\)/ ,
digitNegativeReplace : /^\s*\(([.\d]+)\)/ ,
// *** isDigit ***
digitTest : /^[\-+(]?\d+[)]?$/ ,
digitReplace : /[,.'"\s]/g
2015-08-23 18:22:56 +00:00
2015-10-18 18:21:11 +00:00
} ,
2015-03-28 20:03:50 +00:00
2016-02-15 19:15:22 +00:00
// digit sort, text location
2015-10-18 18:21:11 +00:00
string : {
max : 1 ,
min : - 1 ,
emptymin : 1 ,
emptymax : - 1 ,
zero : 0 ,
none : 0 ,
'null' : 0 ,
top : true ,
bottom : false
} ,
2015-03-28 20:03:50 +00:00
2016-01-15 13:52:22 +00:00
keyCodes : {
enter : 13
} ,
2015-11-23 04:05:06 +00:00
// placeholder date parser data (globalize)
dates : { } ,
2015-10-18 18:21:11 +00:00
// These methods can be applied on table.config instance
instanceMethods : { } ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
/ *
▄ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ ▄
▀ █ ▄ █ █ ▄ ▄ █ █ █ █ █ █ █ █ ▄ ▄ █ █
▀ █ ▄ █ █ ▀ ▀ █ █ █ █ █ █ █ █ ▀ ▀ ▀
█ █ █ █ █ ▀ █ █ █ █ █ █ █ █ ▀ █ █ █ █ ▀ █ █
* /
setup : function ( table , c ) {
// if no thead or tbody, or tablesorter is already present, quit
if ( ! table || ! table . tHead || table . tBodies . length === 0 || table . hasInitialized === true ) {
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2015-10-18 18:21:11 +00:00
if ( table . hasInitialized ) {
console . warn ( 'Stopping initialization. Tablesorter has already been initialized' ) ;
2015-03-28 20:03:50 +00:00
} else {
2015-12-13 22:24:42 +00:00
console . error ( 'Stopping initialization! No table, thead or tbody' , table ) ;
2015-03-28 20:03:50 +00:00
}
}
2015-10-18 18:21:11 +00:00
return ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
var tmp = '' ,
$table = $ ( table ) ,
meta = $ . metadata ;
// initialization flag
table . hasInitialized = false ;
// table is being processed flag
table . isProcessing = true ;
// make sure to store the config object
table . config = c ;
// save the settings where they read
$ . data ( table , 'tablesorter' , c ) ;
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2016-09-23 16:45:10 +00:00
console [ console . group ? 'group' : 'log' ] ( 'Initializing tablesorter v' + ts . version ) ;
2015-10-18 18:21:11 +00:00
$ . data ( table , 'startoveralltimer' , new Date ( ) ) ;
}
// removing this in version 3 (only supports jQuery 1.7+)
c . supportsDataObject = ( function ( version ) {
version [ 0 ] = parseInt ( version [ 0 ] , 10 ) ;
return ( version [ 0 ] > 1 ) || ( version [ 0 ] === 1 && parseInt ( version [ 1 ] , 10 ) >= 4 ) ;
} ) ( $ . fn . jquery . split ( '.' ) ) ;
// ensure case insensitivity
c . emptyTo = c . emptyTo . toLowerCase ( ) ;
c . stringTo = c . stringTo . toLowerCase ( ) ;
2015-10-20 17:47:05 +00:00
c . last = { sortList : [ ] , clickedIndex : - 1 } ;
2015-10-18 18:21:11 +00:00
// add table theme class only if there isn't already one there
if ( ! /tablesorter\-/ . test ( $table . attr ( 'class' ) ) ) {
tmp = ( c . theme !== '' ? ' tablesorter-' + c . theme : '' ) ;
}
// give the table a unique id, which will be used in namespace binding
if ( ! c . namespace ) {
c . namespace = '.tablesorter' + Math . random ( ) . toString ( 16 ) . slice ( 2 ) ;
} else {
// make sure namespace starts with a period & doesn't have weird characters
c . namespace = '.' + c . namespace . replace ( ts . regex . nonWord , '' ) ;
}
2017-05-16 20:33:15 +00:00
c . table = table ;
c . $table = $table
// add namespace to table to allow bindings on extra elements to target
// the parent table (e.g. parser-input-select)
. addClass ( ts . css . table + ' ' + c . tableClass + tmp + ' ' + c . namespace . slice ( 1 ) )
. attr ( 'role' , 'grid' ) ;
c . $headers = $table . find ( c . selectorHeaders ) ;
2015-10-18 18:21:11 +00:00
c . $table . children ( ) . children ( 'tr' ) . attr ( 'role' , 'row' ) ;
c . $tbodies = $table . children ( 'tbody:not(.' + c . cssInfoBlock + ')' ) . attr ( {
'aria-live' : 'polite' ,
'aria-relevant' : 'all'
} ) ;
if ( c . $table . children ( 'caption' ) . length ) {
tmp = c . $table . children ( 'caption' ) [ 0 ] ;
if ( ! tmp . id ) { tmp . id = c . namespace . slice ( 1 ) + 'caption' ; }
c . $table . attr ( 'aria-labelledby' , tmp . id ) ;
}
c . widgetInit = { } ; // keep a list of initialized widgets
// change textExtraction via data-attribute
c . textExtraction = c . $table . attr ( 'data-text-extraction' ) || c . textExtraction || 'basic' ;
// build headers
ts . buildHeaders ( c ) ;
// fixate columns if the users supplies the fixedWidth option
// do this after theme has been applied
ts . fixColumnWidth ( table ) ;
2015-10-31 15:08:21 +00:00
// add widgets from class name
ts . addWidgetFromClass ( table ) ;
2015-10-18 18:21:11 +00:00
// add widget options before parsing (e.g. grouping widget has parser settings)
2015-10-31 15:08:21 +00:00
ts . applyWidgetOptions ( table ) ;
2015-10-18 18:21:11 +00:00
// try to auto detect column type, and store in tables config
ts . setupParsers ( c ) ;
// start total row count at zero
c . totalRows = 0 ;
2016-11-27 01:40:00 +00:00
ts . validateOptions ( c ) ;
2015-10-18 18:21:11 +00:00
// build the cache for the tbody cells
// delayInit will delay building the cache until the user starts a sort
if ( ! c . delayInit ) { ts . buildCache ( c ) ; }
// bind all header events and methods
ts . bindEvents ( table , c . $headers , true ) ;
ts . bindMethods ( c ) ;
// get sort list from jQuery data or metadata
// in jQuery < 1.4, an error occurs when calling $table.data()
if ( c . supportsDataObject && typeof $table . data ( ) . sortlist !== 'undefined' ) {
c . sortList = $table . data ( ) . sortlist ;
} else if ( meta && ( $table . metadata ( ) && $table . metadata ( ) . sortlist ) ) {
c . sortList = $table . metadata ( ) . sortlist ;
}
// apply widget init code
ts . applyWidget ( table , true ) ;
// if user has supplied a sort list to constructor
if ( c . sortList . length > 0 ) {
2015-10-22 21:41:34 +00:00
ts . sortOn ( c , c . sortList , { } , ! c . initWidgets ) ;
2015-10-18 18:21:11 +00:00
} else {
ts . setHeadersCss ( c ) ;
if ( c . initWidgets ) {
// apply widget format
ts . applyWidget ( table , false ) ;
2015-05-17 20:32:53 +00:00
}
2015-10-18 18:21:11 +00:00
}
// show processesing icon
if ( c . showProcessing ) {
$table
. unbind ( 'sortBegin' + c . namespace + ' sortEnd' + c . namespace )
. bind ( 'sortBegin' + c . namespace + ' sortEnd' + c . namespace , function ( e ) {
2015-11-15 04:26:08 +00:00
clearTimeout ( c . timerProcessing ) ;
2015-10-18 18:21:11 +00:00
ts . isProcessing ( table ) ;
if ( e . type === 'sortBegin' ) {
2015-11-15 04:26:08 +00:00
c . timerProcessing = setTimeout ( function ( ) {
2015-10-18 18:21:11 +00:00
ts . isProcessing ( table , true ) ;
} , 500 ) ;
2015-05-06 04:44:06 +00:00
}
2015-10-18 18:21:11 +00:00
} ) ;
}
// initialized
table . hasInitialized = true ;
table . isProcessing = false ;
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2016-09-23 16:45:10 +00:00
console . log ( 'Overall initialization time:' + ts . benchmark ( $ . data ( table , 'startoveralltimer' ) ) ) ;
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) && console . groupEnd ) { console . groupEnd ( ) ; }
2015-10-18 18:21:11 +00:00
}
2015-12-02 01:38:56 +00:00
$table . triggerHandler ( 'tablesorter-initialized' , table ) ;
2015-10-18 18:21:11 +00:00
if ( typeof c . initialized === 'function' ) {
c . initialized ( table ) ;
}
} ,
bindMethods : function ( c ) {
var $table = c . $table ,
namespace = c . namespace ,
events = ( 'sortReset update updateRows updateAll updateHeaders addRows updateCell updateComplete ' +
'sorton appendCache updateCache applyWidgetId applyWidgets refreshWidgets destroy mouseup ' +
'mouseleave ' ) . split ( ' ' )
. join ( namespace + ' ' ) ;
// apply easy methods that trigger bound events
$table
. unbind ( events . replace ( ts . regex . spaces , ' ' ) )
. bind ( 'sortReset' + namespace , function ( e , callback ) {
e . stopPropagation ( ) ;
// using this.config to ensure functions are getting a non-cached version of the config
2017-04-02 11:33:20 +00:00
ts . sortReset ( this . config , function ( table ) {
if ( table . isApplyingWidgets ) {
// multiple triggers in a row... filterReset, then sortReset - see #1361
// wait to update widgets
setTimeout ( function ( ) {
ts . applyWidget ( table , '' , callback ) ;
} , 100 ) ;
} else {
ts . applyWidget ( table , '' , callback ) ;
}
} ) ;
2015-10-18 18:21:11 +00:00
} )
. bind ( 'updateAll' + namespace , function ( e , resort , callback ) {
e . stopPropagation ( ) ;
ts . updateAll ( this . config , resort , callback ) ;
} )
. bind ( 'update' + namespace + ' updateRows' + namespace , function ( e , resort , callback ) {
e . stopPropagation ( ) ;
ts . update ( this . config , resort , callback ) ;
} )
. bind ( 'updateHeaders' + namespace , function ( e , callback ) {
e . stopPropagation ( ) ;
ts . updateHeaders ( this . config , callback ) ;
} )
. bind ( 'updateCell' + namespace , function ( e , cell , resort , callback ) {
e . stopPropagation ( ) ;
ts . updateCell ( this . config , cell , resort , callback ) ;
} )
. bind ( 'addRows' + namespace , function ( e , $row , resort , callback ) {
e . stopPropagation ( ) ;
ts . addRows ( this . config , $row , resort , callback ) ;
} )
. bind ( 'updateComplete' + namespace , function ( ) {
this . isUpdating = false ;
} )
. bind ( 'sorton' + namespace , function ( e , list , callback , init ) {
e . stopPropagation ( ) ;
ts . sortOn ( this . config , list , callback , init ) ;
} )
. bind ( 'appendCache' + namespace , function ( e , callback , init ) {
e . stopPropagation ( ) ;
ts . appendCache ( this . config , init ) ;
if ( $ . isFunction ( callback ) ) {
callback ( this ) ;
2015-05-06 04:44:06 +00:00
}
2015-10-18 18:21:11 +00:00
} )
// $tbodies variable is used by the tbody sorting widget
. bind ( 'updateCache' + namespace , function ( e , callback , $tbodies ) {
e . stopPropagation ( ) ;
ts . updateCache ( this . config , callback , $tbodies ) ;
} )
. bind ( 'applyWidgetId' + namespace , function ( e , id ) {
e . stopPropagation ( ) ;
2015-12-13 22:24:42 +00:00
ts . applyWidgetId ( this , id ) ;
2015-10-18 18:21:11 +00:00
} )
2017-09-28 02:07:28 +00:00
. bind ( 'applyWidgets' + namespace , function ( e , callback ) {
2015-10-18 18:21:11 +00:00
e . stopPropagation ( ) ;
2017-09-28 02:07:28 +00:00
// apply widgets (false = not initializing)
ts . applyWidget ( this , false , callback ) ;
2015-10-18 18:21:11 +00:00
} )
. bind ( 'refreshWidgets' + namespace , function ( e , all , dontapply ) {
e . stopPropagation ( ) ;
ts . refreshWidgets ( this , all , dontapply ) ;
} )
2015-12-13 22:24:42 +00:00
. bind ( 'removeWidget' + namespace , function ( e , name , refreshing ) {
e . stopPropagation ( ) ;
ts . removeWidget ( this , name , refreshing ) ;
} )
2015-10-18 18:21:11 +00:00
. bind ( 'destroy' + namespace , function ( e , removeClasses , callback ) {
e . stopPropagation ( ) ;
ts . destroy ( this , removeClasses , callback ) ;
} )
. bind ( 'resetToLoadState' + namespace , function ( e ) {
e . stopPropagation ( ) ;
// remove all widgets
ts . removeWidget ( this , true , false ) ;
2016-11-27 01:40:00 +00:00
var tmp = $ . extend ( true , { } , c . originalSettings ) ;
2015-10-18 18:21:11 +00:00
// restore original settings; this clears out current settings, but does not clear
// values saved to storage.
2017-04-02 11:33:20 +00:00
c = $ . extend ( true , { } , ts . defaults , tmp ) ;
2016-11-27 01:40:00 +00:00
c . originalSettings = tmp ;
2015-10-18 18:21:11 +00:00
this . hasInitialized = false ;
// setup the entire table again
ts . setup ( this , c ) ;
} ) ;
} ,
2015-05-06 04:44:06 +00:00
2015-10-18 18:21:11 +00:00
bindEvents : function ( table , $headers , core ) {
table = $ ( table ) [ 0 ] ;
var tmp ,
c = table . config ,
namespace = c . namespace ,
downTarget = null ;
if ( core !== true ) {
$headers . addClass ( namespace . slice ( 1 ) + '_extra_headers' ) ;
2017-09-28 02:07:28 +00:00
tmp = ts . getClosest ( $headers , 'table' ) ;
if ( tmp . length && tmp [ 0 ] . nodeName === 'TABLE' && tmp [ 0 ] !== table ) {
$ ( tmp [ 0 ] ) . addClass ( namespace . slice ( 1 ) + '_extra_table' ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
}
tmp = ( c . pointerDown + ' ' + c . pointerUp + ' ' + c . pointerClick + ' sort keyup ' )
. replace ( ts . regex . spaces , ' ' )
. split ( ' ' )
. join ( namespace + ' ' ) ;
// apply event handling to headers and/or additional headers (stickyheaders, scroller, etc)
$headers
// http://stackoverflow.com/questions/5312849/jquery-find-self;
. find ( c . selectorSort )
. add ( $headers . filter ( c . selectorSort ) )
. unbind ( tmp )
. bind ( tmp , function ( e , external ) {
var $cell , cell , temp ,
$target = $ ( e . target ) ,
// wrap event type in spaces, so the match doesn't trigger on inner words
type = ' ' + e . type + ' ' ;
// only recognize left clicks
if ( ( ( e . which || e . button ) !== 1 && ! type . match ( ' ' + c . pointerClick + ' | sort | keyup ' ) ) ||
// allow pressing enter
2016-01-15 13:52:22 +00:00
( type === ' keyup ' && e . which !== ts . keyCodes . enter ) ||
2015-10-18 18:21:11 +00:00
// allow triggering a click event (e.which is undefined) & ignore physical clicks
( type . match ( ' ' + c . pointerClick + ' ' ) && typeof e . which !== 'undefined' ) ) {
return ;
}
// ignore mouseup if mousedown wasn't on the same target
if ( type . match ( ' ' + c . pointerUp + ' ' ) && downTarget !== e . target && external !== true ) {
return ;
}
// set target on mousedown
if ( type . match ( ' ' + c . pointerDown + ' ' ) ) {
downTarget = e . target ;
// preventDefault needed or jQuery v1.3.2 and older throws an
// "Uncaught TypeError: handler.apply is not a function" error
temp = $target . jquery . split ( '.' ) ;
if ( temp [ 0 ] === '1' && temp [ 1 ] < 4 ) { e . preventDefault ( ) ; }
return ;
}
downTarget = null ;
// prevent sort being triggered on form elements
if ( ts . regex . formElements . test ( e . target . nodeName ) ||
// nosort class name, or elements within a nosort container
$target . hasClass ( c . cssNoSort ) || $target . parents ( '.' + c . cssNoSort ) . length > 0 ||
// elements within a button
$target . parents ( 'button' ) . length > 0 ) {
return ! c . cancelSelection ;
}
if ( c . delayInit && ts . isEmptyObject ( c . cache ) ) {
ts . buildCache ( c ) ;
}
2017-12-13 21:17:20 +00:00
$cell = ts . getClosest ( $ ( this ) , '.' + ts . css . header ) ;
2015-10-18 18:21:11 +00:00
// reference original table headers and find the same cell
// don't use $headers or IE8 throws an error - see #987
temp = $headers . index ( $cell ) ;
2015-10-20 17:47:05 +00:00
c . last . clickedIndex = ( temp < 0 ) ? $cell . attr ( 'data-column' ) : temp ;
2015-10-18 18:21:11 +00:00
// use column index if $headers is undefined
2015-10-20 17:47:05 +00:00
cell = c . $headers [ c . last . clickedIndex ] ;
2015-10-18 18:21:11 +00:00
if ( cell && ! cell . sortDisabled ) {
ts . initSort ( c , cell , e ) ;
}
} ) ;
if ( c . cancelSelection ) {
// cancel selection
$headers
. attr ( 'unselectable' , 'on' )
. bind ( 'selectstart' , false )
. css ( {
'user-select' : 'none' ,
'MozUserSelect' : 'none' // not needed for jQuery 1.8+
} ) ;
}
} ,
buildHeaders : function ( c ) {
var $temp , icon , timer , indx ;
c . headerList = [ ] ;
c . headerContent = [ ] ;
2015-10-21 16:03:14 +00:00
c . sortVars = [ ] ;
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2015-10-18 18:21:11 +00:00
timer = new Date ( ) ;
}
// children tr in tfoot - see issue #196 & #547
2015-12-13 22:24:42 +00:00
// don't pass table.config to computeColumnIndex here - widgets (math) pass it to "quickly" index tbody cells
2015-10-18 18:21:11 +00:00
c . columns = ts . computeColumnIndex ( c . $table . children ( 'thead, tfoot' ) . children ( 'tr' ) ) ;
// add icon if cssIcon option exists
icon = c . cssIcon ?
'<i class="' + ( c . cssIcon === ts . css . icon ? ts . css . icon : c . cssIcon + ' ' + ts . css . icon ) + '"></i>' :
'' ;
// redefine c.$headers here in case of an updateAll that replaces or adds an entire header cell - see #683
c . $headers = $ ( $ . map ( c . $table . find ( c . selectorHeaders ) , function ( elem , index ) {
2017-12-13 21:17:20 +00:00
var configHeaders , header , column , template , tmp ,
2015-10-18 18:21:11 +00:00
$elem = $ ( elem ) ;
// ignore cell (don't add it to c.$headers) if row has ignoreRow class
2017-12-13 21:17:20 +00:00
if ( ts . getClosest ( $elem , 'tr' ) . hasClass ( c . cssIgnoreRow ) ) { return ; }
// transfer data-column to element if not th/td - #1459
if ( ! /(th|td)/i . test ( elem . nodeName ) ) {
tmp = ts . getClosest ( $elem , 'th, td' ) ;
$elem . attr ( 'data-column' , tmp . attr ( 'data-column' ) ) ;
}
2015-10-18 18:21:11 +00:00
// make sure to get header cell & not column indexed cell
configHeaders = ts . getColumnData ( c . table , c . headers , index , true ) ;
// save original header content
c . headerContent [ index ] = $elem . html ( ) ;
// if headerTemplate is empty, don't reformat the header cell
if ( c . headerTemplate !== '' && ! $elem . find ( '.' + ts . css . headerIn ) . length ) {
// set up header template
template = c . headerTemplate
. replace ( ts . regex . templateContent , $elem . html ( ) )
. replace ( ts . regex . templateIcon , $elem . find ( '.' + ts . css . icon ) . length ? '' : icon ) ;
if ( c . onRenderTemplate ) {
header = c . onRenderTemplate . apply ( $elem , [ index , template ] ) ;
// only change t if something is returned
if ( header && typeof header === 'string' ) {
template = header ;
}
}
$elem . html ( '<div class="' + ts . css . headerIn + '">' + template + '</div>' ) ; // faster than wrapInner
}
if ( c . onRenderHeader ) {
c . onRenderHeader . apply ( $elem , [ index , c , c . $table ] ) ;
}
2017-12-13 21:17:20 +00:00
column = parseInt ( $elem . attr ( 'data-column' ) , 10 ) ;
2015-10-21 16:03:14 +00:00
elem . column = column ;
2016-08-01 01:48:27 +00:00
tmp = ts . getOrder ( ts . getData ( $elem , configHeaders , 'sortInitialOrder' ) || c . sortInitialOrder ) ;
2015-10-21 16:03:14 +00:00
// this may get updated numerous times if there are multiple rows
c . sortVars [ column ] = {
count : - 1 , // set to -1 because clicking on the header automatically adds one
2016-08-01 01:48:27 +00:00
order : tmp ?
( c . sortReset ? [ 1 , 0 , 2 ] : [ 1 , 0 ] ) : // desc, asc, unsorted
( c . sortReset ? [ 0 , 1 , 2 ] : [ 0 , 1 ] ) , // asc, desc, unsorted
2015-10-21 16:03:14 +00:00
lockedOrder : false
} ;
2015-10-18 18:21:11 +00:00
tmp = ts . getData ( $elem , configHeaders , 'lockedOrder' ) || false ;
if ( typeof tmp !== 'undefined' && tmp !== false ) {
2015-10-21 16:03:14 +00:00
c . sortVars [ column ] . lockedOrder = true ;
2016-08-01 01:48:27 +00:00
c . sortVars [ column ] . order = ts . getOrder ( tmp ) ? [ 1 , 1 ] : [ 0 , 0 ] ;
2015-10-18 18:21:11 +00:00
}
// add cell to headerList
c . headerList [ index ] = elem ;
2017-09-28 02:07:28 +00:00
$elem . addClass ( ts . css . header + ' ' + c . cssHeader ) ;
2015-10-18 18:21:11 +00:00
// add to parent in case there are multiple rows
2017-09-28 02:07:28 +00:00
ts . getClosest ( $elem , 'tr' )
2015-10-18 18:21:11 +00:00
. addClass ( ts . css . headerRow + ' ' + c . cssHeaderRow )
. attr ( 'role' , 'row' ) ;
// allow keyboard cursor to focus on element
if ( c . tabIndex ) {
$elem . attr ( 'tabindex' , 0 ) ;
}
return elem ;
} ) ) ;
// cache headers per column
c . $headerIndexed = [ ] ;
for ( indx = 0 ; indx < c . columns ; indx ++ ) {
2015-10-31 15:08:21 +00:00
// colspan in header making a column undefined
if ( ts . isEmptyObject ( c . sortVars [ indx ] ) ) {
c . sortVars [ indx ] = { } ;
}
2017-12-13 21:17:20 +00:00
// Use c.$headers.parent() in case selectorHeaders doesn't point to the th/td
2015-10-18 18:21:11 +00:00
$temp = c . $headers . filter ( '[data-column="' + indx + '"]' ) ;
// target sortable column cells, unless there are none, then use non-sortable cells
// .last() added in jQuery 1.4; use .filter(':last') to maintain compatibility with jQuery v1.2.6
c . $headerIndexed [ indx ] = $temp . length ?
$temp . not ( '.sorter-false' ) . length ?
$temp . not ( '.sorter-false' ) . filter ( ':last' ) :
$temp . filter ( ':last' ) :
$ ( ) ;
}
c . $table . find ( c . selectorHeaders ) . attr ( {
scope : 'col' ,
role : 'columnheader'
} ) ;
// enable/disable sorting
ts . updateHeader ( c ) ;
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2015-10-18 18:21:11 +00:00
console . log ( 'Built headers:' + ts . benchmark ( timer ) ) ;
console . log ( c . $headers ) ;
}
} ,
// Use it to add a set of methods to table.config which will be available for all tables.
// This should be done before table initialization
addInstanceMethods : function ( methods ) {
$ . extend ( ts . instanceMethods , methods ) ;
} ,
/ *
█ █ █ █ █ ▄ ▄ █ █ █ █ ▄ █ █ █ █ █ ▄ ▄ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ ▄ ▄ █ █ █ █ █
█ █ ▄ ▄ █ █ █ █ ▄ ▄ █ █ █ █ ▄ ▄ █ █ ▀ █ ▄ █ █ ▄ ▄ █ █ ▄ ▄ █ █ ▀ █ ▄
█ █ ▀ ▀ ▀ █ █ ▀ ▀ █ █ █ █ ▀ █ █ ▀ █ ▄ █ █ ▀ ▀ █ █ ▀ █ █ ▀ █ ▄
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ ▀ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ ▀
* /
setupParsers : function ( c , $tbodies ) {
var rows , list , span , max , colIndex , indx , header , configHeaders ,
noParser , parser , extractor , time , tbody , len ,
table = c . table ,
tbodyIndex = 0 ,
2018-03-18 13:49:07 +00:00
debug = ts . debug ( c , 'core' ) ,
debugOutput = { } ;
2015-10-18 18:21:11 +00:00
// update table bodies in case we start with an empty table
c . $tbodies = c . $table . children ( 'tbody:not(.' + c . cssInfoBlock + ')' ) ;
tbody = typeof $tbodies === 'undefined' ? c . $tbodies : $tbodies ;
len = tbody . length ;
if ( len === 0 ) {
2018-03-18 13:49:07 +00:00
return debug ? console . warn ( 'Warning: *Empty table!* Not building a parser cache' ) : '' ;
} else if ( debug ) {
2015-10-18 18:21:11 +00:00
time = new Date ( ) ;
console [ console . group ? 'group' : 'log' ] ( 'Detecting parsers for each column' ) ;
}
list = {
extractors : [ ] ,
parsers : [ ]
} ;
while ( tbodyIndex < len ) {
rows = tbody [ tbodyIndex ] . rows ;
if ( rows . length ) {
colIndex = 0 ;
max = c . columns ;
for ( indx = 0 ; indx < max ; indx ++ ) {
header = c . $headerIndexed [ colIndex ] ;
if ( header && header . length ) {
2017-04-02 11:33:20 +00:00
// get column indexed table cell; adding true parameter fixes #1362 but
// it would break backwards compatibility...
configHeaders = ts . getColumnData ( table , c . headers , colIndex ) ; // , true );
2015-03-28 20:03:50 +00:00
// get column parser/extractor
2015-10-18 18:21:11 +00:00
extractor = ts . getParserById ( ts . getData ( header , configHeaders , 'extractor' ) ) ;
parser = ts . getParserById ( ts . getData ( header , configHeaders , 'sorter' ) ) ;
noParser = ts . getData ( header , configHeaders , 'parser' ) === 'false' ;
2015-03-28 20:03:50 +00:00
// empty cells behaviour - keeping emptyToBottom for backwards compatibility
2015-10-18 18:21:11 +00:00
c . empties [ colIndex ] = (
ts . getData ( header , configHeaders , 'empty' ) ||
c . emptyTo || ( c . emptyToBottom ? 'bottom' : 'top' ) ) . toLowerCase ( ) ;
2015-03-28 20:03:50 +00:00
// text strings behaviour in numerical sorts
2015-10-18 18:21:11 +00:00
c . strings [ colIndex ] = (
ts . getData ( header , configHeaders , 'string' ) ||
c . stringTo ||
'max' ) . toLowerCase ( ) ;
if ( noParser ) {
parser = ts . getParserById ( 'no-parser' ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
if ( ! extractor ) {
2015-03-28 20:03:50 +00:00
// For now, maybe detect someday
2015-10-18 18:21:11 +00:00
extractor = false ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
if ( ! parser ) {
2015-10-31 15:08:21 +00:00
parser = ts . detectParserForColumn ( c , rows , - 1 , colIndex ) ;
2015-03-28 20:03:50 +00:00
}
2018-03-18 13:49:07 +00:00
if ( debug ) {
debugOutput [ '(' + colIndex + ') ' + header . text ( ) ] = {
2015-10-18 18:21:11 +00:00
parser : parser . id ,
extractor : extractor ? extractor . id : 'none' ,
string : c . strings [ colIndex ] ,
empty : c . empties [ colIndex ]
2015-07-24 23:23:00 +00:00
} ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
list . parsers [ colIndex ] = parser ;
list . extractors [ colIndex ] = extractor ;
span = header [ 0 ] . colSpan - 1 ;
if ( span > 0 ) {
colIndex += span ;
max += span ;
2015-12-13 22:24:42 +00:00
while ( span + 1 > 0 ) {
// set colspan columns to use the same parsers & extractors
list . parsers [ colIndex - span ] = parser ;
list . extractors [ colIndex - span ] = extractor ;
span -- ;
}
2015-10-18 18:21:11 +00:00
}
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
colIndex ++ ;
2015-03-28 20:03:50 +00:00
}
}
2015-10-18 18:21:11 +00:00
tbodyIndex += ( list . parsers . length ) ? len : 1 ;
}
2018-03-18 13:49:07 +00:00
if ( debug ) {
if ( ! ts . isEmptyObject ( debugOutput ) ) {
console [ console . table ? 'table' : 'log' ] ( debugOutput ) ;
2015-10-18 18:21:11 +00:00
} else {
console . warn ( ' No parsers detected!' ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
console . log ( 'Completed detecting parsers' + ts . benchmark ( time ) ) ;
if ( console . groupEnd ) { console . groupEnd ( ) ; }
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
c . parsers = list . parsers ;
c . extractors = list . extractors ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
addParser : function ( parser ) {
var indx ,
len = ts . parsers . length ,
add = true ;
for ( indx = 0 ; indx < len ; indx ++ ) {
if ( ts . parsers [ indx ] . id . toLowerCase ( ) === parser . id . toLowerCase ( ) ) {
add = false ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
}
if ( add ) {
2016-03-02 05:00:22 +00:00
ts . parsers [ ts . parsers . length ] = parser ;
2015-10-18 18:21:11 +00:00
}
} ,
getParserById : function ( name ) {
2018-03-18 13:49:07 +00:00
/*jshint eqeqeq:false */ // eslint-disable-next-line eqeqeq
2015-10-18 18:21:11 +00:00
if ( name == 'false' ) { return false ; }
var indx ,
len = ts . parsers . length ;
for ( indx = 0 ; indx < len ; indx ++ ) {
if ( ts . parsers [ indx ] . id . toLowerCase ( ) === ( name . toString ( ) ) . toLowerCase ( ) ) {
return ts . parsers [ indx ] ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
}
return false ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
detectParserForColumn : function ( c , rows , rowIndex , cellIndex ) {
2015-11-23 04:05:06 +00:00
var cur , $node , row ,
2015-10-18 18:21:11 +00:00
indx = ts . parsers . length ,
node = false ,
nodeValue = '' ,
2018-03-18 13:49:07 +00:00
debug = ts . debug ( c , 'core' ) ,
2015-10-18 18:21:11 +00:00
keepLooking = true ;
while ( nodeValue === '' && keepLooking ) {
rowIndex ++ ;
2015-11-23 04:05:06 +00:00
row = rows [ rowIndex ] ;
// stop looking after 50 empty rows
if ( row && rowIndex < 50 ) {
if ( row . className . indexOf ( ts . cssIgnoreRow ) < 0 ) {
node = rows [ rowIndex ] . cells [ cellIndex ] ;
nodeValue = ts . getElementText ( c , node , cellIndex ) ;
$node = $ ( node ) ;
2018-03-18 13:49:07 +00:00
if ( debug ) {
2015-11-23 04:05:06 +00:00
console . log ( 'Checking if value was empty on row ' + rowIndex + ', column: ' +
cellIndex + ': "' + nodeValue + '"' ) ;
}
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
} else {
keepLooking = false ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
}
while ( -- indx >= 0 ) {
cur = ts . parsers [ indx ] ;
// ignore the default text parser because it will always be true
if ( cur && cur . id !== 'text' && cur . is && cur . is ( nodeValue , c . table , node , $node ) ) {
return cur ;
2015-03-28 20:03:50 +00:00
}
}
2015-10-18 18:21:11 +00:00
// nothing found, return the generic parser (text)
return ts . getParserById ( 'text' ) ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
getElementText : function ( c , node , cellIndex ) {
if ( ! node ) { return '' ; }
var tmp ,
extract = c . textExtraction || '' ,
// node could be a jquery object
// http://jsperf.com/jquery-vs-instanceof-jquery/2
$node = node . jquery ? node : $ ( node ) ;
if ( typeof extract === 'string' ) {
// check data-attribute first when set to 'basic'; don't use node.innerText - it's really slow!
// http://www.kellegous.com/j/2013/02/27/innertext-vs-textcontent/
if ( extract === 'basic' && typeof ( tmp = $node . attr ( c . textAttribute ) ) !== 'undefined' ) {
return $ . trim ( tmp ) ;
}
return $ . trim ( node . textContent || $node . text ( ) ) ;
} else {
if ( typeof extract === 'function' ) {
return $ . trim ( extract ( $node [ 0 ] , c . table , cellIndex ) ) ;
} else if ( typeof ( tmp = ts . getColumnData ( c . table , extract , cellIndex ) ) === 'function' ) {
return $ . trim ( tmp ( $node [ 0 ] , c . table , cellIndex ) ) ;
}
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
// fallback
return $ . trim ( $node [ 0 ] . textContent || $node . text ( ) ) ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
// centralized function to extract/parse cell contents
getParsedText : function ( c , cell , colIndex , txt ) {
if ( typeof txt === 'undefined' ) {
txt = ts . getElementText ( c , cell , colIndex ) ;
}
// if no parser, make sure to return the txt
var val = '' + txt ,
parser = c . parsers [ colIndex ] ,
extractor = c . extractors [ colIndex ] ;
if ( parser ) {
// do extract before parsing, if there is one
if ( extractor && typeof extractor . format === 'function' ) {
txt = extractor . format ( txt , c . table , cell , colIndex ) ;
}
// allow parsing if the string is empty, previously parsing would change it to zero,
// in case the parser needs to extract data from the table cell attributes
val = parser . id === 'no-parser' ? '' :
// make sure txt is a string (extractor may have converted it)
parser . format ( '' + txt , c . table , cell , colIndex ) ;
if ( c . ignoreCase && typeof val === 'string' ) {
val = val . toLowerCase ( ) ;
2015-03-28 20:03:50 +00:00
}
}
2015-10-18 18:21:11 +00:00
return val ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
/ *
▄ █ █ █ █ ▄ ▄ █ █ █ █ ▄ ▄ █ █ █ █ ▄ █ █ █ █ █ █ █ █ █ █
█ █ ▀ ▀ █ █ ▄ ▄ █ █ █ █ ▀ ▀ █ █ ▄ ▄ █ █ █ █ ▄ ▄
█ █ ▄ ▄ █ █ ▀ ▀ █ █ █ █ ▄ ▄ █ █ ▀ ▀ █ █ █ █ ▀ ▀
▀ █ █ █ █ ▀ █ █ █ █ ▀ █ █ █ █ ▀ █ █ █ █ █ █ █ █ █ █
* /
buildCache : function ( c , callback , $tbodies ) {
var cache , val , txt , rowIndex , colIndex , tbodyIndex , $tbody , $row ,
cols , $cells , cell , cacheTime , totalRows , rowData , prevRowData ,
2015-12-13 22:24:42 +00:00
colMax , span , cacheIndex , hasParser , max , len , index ,
2015-10-18 18:21:11 +00:00
table = c . table ,
2018-03-18 13:49:07 +00:00
parsers = c . parsers ,
debug = ts . debug ( c , 'core' ) ;
2015-10-18 18:21:11 +00:00
// update tbody variable
c . $tbodies = c . $table . children ( 'tbody:not(.' + c . cssInfoBlock + ')' ) ;
$tbody = typeof $tbodies === 'undefined' ? c . $tbodies : $tbodies ,
c . cache = { } ;
c . totalRows = 0 ;
// if no parsers found, return - it's an empty table.
if ( ! parsers ) {
2018-03-18 13:49:07 +00:00
return debug ? console . warn ( 'Warning: *Empty table!* Not building a cache' ) : '' ;
2015-10-18 18:21:11 +00:00
}
2018-03-18 13:49:07 +00:00
if ( debug ) {
2015-10-18 18:21:11 +00:00
cacheTime = new Date ( ) ;
}
// processing icon
if ( c . showProcessing ) {
ts . isProcessing ( table , true ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
for ( tbodyIndex = 0 ; tbodyIndex < $tbody . length ; tbodyIndex ++ ) {
colMax = [ ] ; // column max value per tbody
cache = c . cache [ tbodyIndex ] = {
normalized : [ ] // array of normalized row data; last entry contains 'rowData' above
// colMax: # // added at the end
} ;
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
totalRows = ( $tbody [ tbodyIndex ] && $tbody [ tbodyIndex ] . rows . length ) || 0 ;
for ( rowIndex = 0 ; rowIndex < totalRows ; ++ rowIndex ) {
rowData = {
// order: original row order #
// $row : jQuery Object[]
child : [ ] , // child row text (filter widget)
raw : [ ] // original row text
} ;
/** Add the table data to main data array */
$row = $ ( $tbody [ tbodyIndex ] . rows [ rowIndex ] ) ;
cols = [ ] ;
2016-08-01 01:48:27 +00:00
// ignore "remove-me" rows
if ( $row . hasClass ( c . selectorRemove . slice ( 1 ) ) ) {
continue ;
}
2015-10-18 18:21:11 +00:00
// if this is a child row, add it to the last row's children and continue to the next row
// ignore child row class, if it is the first row
if ( $row . hasClass ( c . cssChildRow ) && rowIndex !== 0 ) {
len = cache . normalized . length - 1 ;
prevRowData = cache . normalized [ len ] [ c . columns ] ;
prevRowData . $row = prevRowData . $row . add ( $row ) ;
// add 'hasChild' class name to parent row
if ( ! $row . prev ( ) . hasClass ( c . cssChildRow ) ) {
$row . prev ( ) . addClass ( ts . css . cssHasChild ) ;
2015-10-04 14:26:07 +00:00
}
2015-10-18 18:21:11 +00:00
// save child row content (un-parsed!)
$cells = $row . children ( 'th, td' ) ;
len = prevRowData . child . length ;
prevRowData . child [ len ] = [ ] ;
// child row content does not account for colspans/rowspans; so indexing may be off
cacheIndex = 0 ;
max = c . columns ;
for ( colIndex = 0 ; colIndex < max ; colIndex ++ ) {
cell = $cells [ colIndex ] ;
if ( cell ) {
prevRowData . child [ len ] [ colIndex ] = ts . getParsedText ( c , cell , colIndex ) ;
span = $cells [ colIndex ] . colSpan - 1 ;
if ( span > 0 ) {
cacheIndex += span ;
max += span ;
}
}
cacheIndex ++ ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
// go to the next for loop
continue ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
rowData . $row = $row ;
rowData . order = rowIndex ; // add original row position to rowCache
cacheIndex = 0 ;
max = c . columns ;
for ( colIndex = 0 ; colIndex < max ; ++ colIndex ) {
cell = $row [ 0 ] . cells [ colIndex ] ;
2015-12-13 22:24:42 +00:00
if ( cell && cacheIndex < c . columns ) {
hasParser = typeof parsers [ cacheIndex ] !== 'undefined' ;
2018-03-18 13:49:07 +00:00
if ( ! hasParser && debug ) {
2015-12-13 22:24:42 +00:00
console . warn ( 'No parser found for row: ' + rowIndex + ', column: ' + colIndex +
'; cell containing: "' + $ ( cell ) . text ( ) + '"; does it have a header?' ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
val = ts . getElementText ( c , cell , cacheIndex ) ;
rowData . raw [ cacheIndex ] = val ; // save original row text
2015-12-13 22:24:42 +00:00
// save raw column text even if there is no parser set
2015-10-18 18:21:11 +00:00
txt = ts . getParsedText ( c , cell , cacheIndex , val ) ;
2015-10-21 16:03:14 +00:00
cols [ cacheIndex ] = txt ;
2015-12-13 22:24:42 +00:00
if ( hasParser && ( parsers [ cacheIndex ] . type || '' ) . toLowerCase ( ) === 'numeric' ) {
2015-10-18 18:21:11 +00:00
// determine column max value (ignore sign)
colMax [ cacheIndex ] = Math . max ( Math . abs ( txt ) || 0 , colMax [ cacheIndex ] || 0 ) ;
}
// allow colSpan in tbody
span = cell . colSpan - 1 ;
if ( span > 0 ) {
2015-12-13 22:24:42 +00:00
index = 0 ;
while ( index <= span ) {
// duplicate text (or not) to spanned columns
2016-04-11 21:04:30 +00:00
// instead of setting duplicate span to empty string, use textExtraction to try to get a value
// see http://stackoverflow.com/q/36449711/145346
txt = c . duplicateSpan || index === 0 ?
val :
typeof c . textExtraction !== 'string' ?
ts . getElementText ( c , cell , cacheIndex + index ) || '' :
'' ;
rowData . raw [ cacheIndex + index ] = txt ;
cols [ cacheIndex + index ] = txt ;
2015-12-13 22:24:42 +00:00
index ++ ;
}
2015-10-18 18:21:11 +00:00
cacheIndex += span ;
max += span ;
2015-03-28 20:03:50 +00:00
}
}
2015-10-18 18:21:11 +00:00
cacheIndex ++ ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
// ensure rowData is always in the same location (after the last column)
cols [ c . columns ] = rowData ;
2016-03-02 05:00:22 +00:00
cache . normalized [ cache . normalized . length ] = cols ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
cache . colMax = colMax ;
// total up rows, not including child rows
c . totalRows += cache . normalized . length ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
if ( c . showProcessing ) {
ts . isProcessing ( table ) ; // remove processing icon
2015-03-28 20:03:50 +00:00
}
2018-03-18 13:49:07 +00:00
if ( debug ) {
2015-12-13 22:24:42 +00:00
len = Math . min ( 5 , c . cache [ 0 ] . normalized . length ) ;
console [ console . group ? 'group' : 'log' ] ( 'Building cache for ' + c . totalRows +
2016-08-01 01:48:27 +00:00
' rows (showing ' + len + ' rows in log) and ' + c . columns + ' columns' +
ts . benchmark ( cacheTime ) ) ;
2015-12-02 01:38:56 +00:00
val = { } ;
for ( colIndex = 0 ; colIndex < c . columns ; colIndex ++ ) {
for ( cacheIndex = 0 ; cacheIndex < len ; cacheIndex ++ ) {
if ( ! val [ 'row: ' + cacheIndex ] ) {
val [ 'row: ' + cacheIndex ] = { } ;
}
2015-12-13 22:24:42 +00:00
val [ 'row: ' + cacheIndex ] [ c . $headerIndexed [ colIndex ] . text ( ) ] =
c . cache [ 0 ] . normalized [ cacheIndex ] [ colIndex ] ;
2015-12-02 01:38:56 +00:00
}
}
console [ console . table ? 'table' : 'log' ] ( val ) ;
if ( console . groupEnd ) { console . groupEnd ( ) ; }
2015-10-18 18:21:11 +00:00
}
if ( $ . isFunction ( callback ) ) {
callback ( table ) ;
}
} ,
2015-03-28 20:03:50 +00:00
2015-10-20 01:54:56 +00:00
getColumnText : function ( table , column , callback , rowFilter ) {
2015-10-18 18:21:11 +00:00
table = $ ( table ) [ 0 ] ;
var tbodyIndex , rowIndex , cache , row , tbodyLen , rowLen , raw , parsed , $cell , result ,
hasCallback = typeof callback === 'function' ,
allColumns = column === 'all' ,
data = { raw : [ ] , parsed : [ ] , $cell : [ ] } ,
c = table . config ;
if ( ts . isEmptyObject ( c ) ) {
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2015-10-18 18:21:11 +00:00
console . warn ( 'No cache found - aborting getColumnText function!' ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
} else {
tbodyLen = c . $tbodies . length ;
for ( tbodyIndex = 0 ; tbodyIndex < tbodyLen ; tbodyIndex ++ ) {
cache = c . cache [ tbodyIndex ] . normalized ;
rowLen = cache . length ;
for ( rowIndex = 0 ; rowIndex < rowLen ; rowIndex ++ ) {
2015-10-20 01:54:56 +00:00
row = cache [ rowIndex ] ;
if ( rowFilter && ! row [ c . columns ] . $row . is ( rowFilter ) ) {
continue ;
}
2015-10-18 18:21:11 +00:00
result = true ;
parsed = ( allColumns ) ? row . slice ( 0 , c . columns ) : row [ column ] ;
row = row [ c . columns ] ;
raw = ( allColumns ) ? row . raw : row . raw [ column ] ;
$cell = ( allColumns ) ? row . $row . children ( ) : row . $row . children ( ) . eq ( column ) ;
if ( hasCallback ) {
result = callback ( {
tbodyIndex : tbodyIndex ,
rowIndex : rowIndex ,
parsed : parsed ,
raw : raw ,
$row : row . $row ,
$cell : $cell
} ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
if ( result !== false ) {
2016-03-02 05:00:22 +00:00
data . parsed [ data . parsed . length ] = parsed ;
data . raw [ data . raw . length ] = raw ;
data . $cell [ data . $cell . length ] = $cell ;
2015-03-28 20:03:50 +00:00
}
}
}
2015-10-18 18:21:11 +00:00
// return everything
return data ;
}
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
/ *
█ █ █ █ █ █ █ █ █ ▄ █ █ █ █ █ ▄ ▄ █ █ █ █ ▄ █ █ █ █ █ █ █ █ █ █ █ █
█ █ █ █ █ █ ▄ ▄ █ █ █ █ █ █ █ █ ▄ ▄ █ █ █ █ █ █ ▄ ▄
█ █ █ █ █ █ ▀ ▀ ▀ █ █ █ █ █ █ ▀ ▀ █ █ █ █ █ █ ▀ ▀
▀ █ █ █ █ ▀ █ █ █ █ █ █ █ ▀ █ █ █ █ █ █ █ █ █ █ █ █
* /
setHeadersCss : function ( c ) {
2017-06-02 22:49:41 +00:00
var indx , column ,
2015-10-18 18:21:11 +00:00
list = c . sortList ,
len = list . length ,
none = ts . css . sortNone + ' ' + c . cssNone ,
css = [ ts . css . sortAsc + ' ' + c . cssAsc , ts . css . sortDesc + ' ' + c . cssDesc ] ,
cssIcon = [ c . cssIconAsc , c . cssIconDesc , c . cssIconNone ] ,
aria = [ 'ascending' , 'descending' ] ,
2017-12-13 21:17:20 +00:00
updateColumnSort = function ( $el , index ) {
$el
. removeClass ( none )
. addClass ( css [ index ] )
. attr ( 'aria-sort' , aria [ index ] )
. find ( '.' + ts . css . icon )
. removeClass ( cssIcon [ 2 ] )
. addClass ( cssIcon [ index ] ) ;
} ,
2015-10-18 18:21:11 +00:00
// find the footer
2017-06-02 22:49:41 +00:00
$extras = c . $table
2015-10-18 18:21:11 +00:00
. find ( 'tfoot tr' )
2016-01-11 04:22:16 +00:00
. children ( 'td, th' )
2016-01-15 13:52:22 +00:00
. add ( $ ( c . namespace + '_extra_headers' ) )
2017-06-02 22:49:41 +00:00
. removeClass ( css . join ( ' ' ) ) ,
// remove all header information
$sorted = c . $headers
. add ( $ ( 'thead ' + c . namespace + '_extra_headers' ) )
. removeClass ( css . join ( ' ' ) )
. addClass ( none )
. attr ( 'aria-sort' , 'none' )
. find ( '.' + ts . css . icon )
. removeClass ( cssIcon . join ( ' ' ) )
. end ( ) ;
// add css none to all sortable headers
$sorted
. not ( '.sorter-false' )
2015-10-18 18:21:11 +00:00
. find ( '.' + ts . css . icon )
. addClass ( cssIcon [ 2 ] ) ;
2017-06-02 22:49:41 +00:00
// add disabled css icon class
if ( c . cssIconDisabled ) {
$sorted
. filter ( '.sorter-false' )
. find ( '.' + ts . css . icon )
. addClass ( c . cssIconDisabled ) ;
}
2015-10-18 18:21:11 +00:00
for ( indx = 0 ; indx < len ; indx ++ ) {
// direction = 2 means reset!
if ( list [ indx ] [ 1 ] !== 2 ) {
// multicolumn sorting updating - see #1005
2018-03-18 13:49:07 +00:00
// .not(function() {}) needs jQuery 1.4
// filter(function(i, el) {}) <- el is undefined in jQuery v1.2.6
2015-11-05 02:15:37 +00:00
$sorted = c . $headers . filter ( function ( i ) {
2015-10-20 11:25:34 +00:00
// only include headers that are in the sortList (this includes colspans)
var include = true ,
2015-11-05 02:15:37 +00:00
$el = c . $headers . eq ( i ) ,
2015-10-20 11:25:34 +00:00
col = parseInt ( $el . attr ( 'data-column' ) , 10 ) ,
2017-12-13 21:17:20 +00:00
end = col + ts . getClosest ( $el , 'th, td' ) [ 0 ] . colSpan ;
2015-10-20 11:25:34 +00:00
for ( ; col < end ; col ++ ) {
2015-12-13 22:24:42 +00:00
include = include ? include || ts . isValueInArray ( col , c . sortList ) > - 1 : false ;
2015-10-20 11:25:34 +00:00
}
return include ;
} ) ;
2015-10-18 18:21:11 +00:00
// choose the :last in case there are nested columns
$sorted = $sorted
. not ( '.sorter-false' )
. filter ( '[data-column="' + list [ indx ] [ 0 ] + '"]' + ( len === 1 ? ':last' : '' ) ) ;
if ( $sorted . length ) {
for ( column = 0 ; column < $sorted . length ; column ++ ) {
if ( ! $sorted [ column ] . sortDisabled ) {
2018-01-10 22:18:04 +00:00
updateColumnSort ( $sorted . eq ( column ) , list [ indx ] [ 1 ] ) ;
2015-03-28 20:03:50 +00:00
}
}
2017-12-13 21:17:20 +00:00
}
// add sorted class to footer & extra headers, if they exist
if ( $extras . length ) {
updateColumnSort ( $extras . filter ( '[data-column="' + list [ indx ] [ 0 ] + '"]' ) , list [ indx ] [ 1 ] ) ;
2015-10-18 18:21:11 +00:00
}
2015-07-24 23:23:00 +00:00
}
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
// add verbose aria labels
len = c . $headers . length ;
for ( indx = 0 ; indx < len ; indx ++ ) {
2015-11-10 21:27:30 +00:00
ts . setColumnAriaLabel ( c , c . $headers . eq ( indx ) ) ;
}
} ,
2017-09-28 02:07:28 +00:00
getClosest : function ( $el , selector ) {
// jQuery v1.2.6 doesn't have closest()
if ( $ . fn . closest ) {
2017-12-13 21:17:20 +00:00
return $el . closest ( selector ) ;
2017-09-28 02:07:28 +00:00
}
2017-12-13 21:17:20 +00:00
return $el . is ( selector ) ?
2017-09-28 02:07:28 +00:00
$el :
2017-12-13 21:17:20 +00:00
$el . parents ( selector ) . filter ( ':first' ) ;
2017-09-28 02:07:28 +00:00
} ,
2015-11-10 21:27:30 +00:00
// nextSort (optional), lets you disable next sort text
setColumnAriaLabel : function ( c , $header , nextSort ) {
if ( $header . length ) {
2017-12-13 21:17:20 +00:00
var column = parseInt ( $header . attr ( 'data-column' ) , 10 ) ,
2016-08-01 01:48:27 +00:00
vars = c . sortVars [ column ] ,
2015-10-18 18:21:11 +00:00
tmp = $header . hasClass ( ts . css . sortAsc ) ?
'sortAsc' :
2015-11-10 21:27:30 +00:00
$header . hasClass ( ts . css . sortDesc ) ? 'sortDesc' : 'sortNone' ,
txt = $ . trim ( $header . text ( ) ) + ': ' + ts . language [ tmp ] ;
if ( $header . hasClass ( 'sorter-false' ) || nextSort === false ) {
txt += ts . language . sortDisabled ;
} else {
2016-08-01 01:48:27 +00:00
tmp = ( vars . count + 1 ) % vars . order . length ;
nextSort = vars . order [ tmp ] ;
2015-11-10 21:27:30 +00:00
// if nextSort
txt += ts . language [ nextSort === 0 ? 'nextAsc' : nextSort === 1 ? 'nextDesc' : 'nextNone' ] ;
2015-03-28 20:03:50 +00:00
}
2015-11-10 21:27:30 +00:00
$header . attr ( 'aria-label' , txt ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
updateHeader : function ( c ) {
2015-11-10 21:27:30 +00:00
var index , isDisabled , $header , col ,
2015-10-18 18:21:11 +00:00
table = c . table ,
len = c . $headers . length ;
for ( index = 0 ; index < len ; index ++ ) {
2015-11-10 21:27:30 +00:00
$header = c . $headers . eq ( index ) ;
2015-10-18 18:21:11 +00:00
col = ts . getColumnData ( table , c . headers , index , true ) ;
// add 'sorter-false' class if 'parser-false' is set
2015-11-10 21:27:30 +00:00
isDisabled = ts . getData ( $header , col , 'sorter' ) === 'false' || ts . getData ( $header , col , 'parser' ) === 'false' ;
ts . setColumnSort ( c , $header , isDisabled ) ;
}
} ,
setColumnSort : function ( c , $header , isDisabled ) {
var id = c . table . id ;
$header [ 0 ] . sortDisabled = isDisabled ;
$header [ isDisabled ? 'addClass' : 'removeClass' ] ( 'sorter-false' )
. attr ( 'aria-disabled' , '' + isDisabled ) ;
// disable tab index on disabled cells
if ( c . tabIndex ) {
if ( isDisabled ) {
$header . removeAttr ( 'tabindex' ) ;
} else {
$header . attr ( 'tabindex' , '0' ) ;
2015-10-18 18:21:11 +00:00
}
2015-11-10 21:27:30 +00:00
}
// aria-controls - requires table ID
if ( id ) {
if ( isDisabled ) {
$header . removeAttr ( 'aria-controls' ) ;
} else {
$header . attr ( 'aria-controls' , id ) ;
2015-03-28 20:03:50 +00:00
}
}
2015-10-18 18:21:11 +00:00
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
updateHeaderSortCount : function ( c , list ) {
2015-10-21 16:03:14 +00:00
var col , dir , group , indx , primary , temp , val , order ,
2015-10-18 18:21:11 +00:00
sortList = list || c . sortList ,
len = sortList . length ;
c . sortList = [ ] ;
for ( indx = 0 ; indx < len ; indx ++ ) {
val = sortList [ indx ] ;
// ensure all sortList values are numeric - fixes #127
col = parseInt ( val [ 0 ] , 10 ) ;
// prevents error if sorton array is wrong
2015-10-21 16:03:14 +00:00
if ( col < c . columns ) {
2015-12-13 22:24:42 +00:00
// set order if not already defined - due to colspan header without associated header cell
// adding this check prevents a javascript error
if ( ! c . sortVars [ col ] . order ) {
2016-08-01 01:48:27 +00:00
if ( ts . getOrder ( c . sortInitialOrder ) ) {
order = c . sortReset ? [ 1 , 0 , 2 ] : [ 1 , 0 ] ;
} else {
order = c . sortReset ? [ 0 , 1 , 2 ] : [ 0 , 1 ] ;
}
c . sortVars [ col ] . order = order ;
2015-12-13 22:24:42 +00:00
c . sortVars [ col ] . count = 0 ;
}
2015-10-21 16:03:14 +00:00
order = c . sortVars [ col ] . order ;
2015-10-18 18:21:11 +00:00
dir = ( '' + val [ 1 ] ) . match ( /^(1|d|s|o|n)/ ) ;
dir = dir ? dir [ 0 ] : '' ;
// 0/(a)sc (default), 1/(d)esc, (s)ame, (o)pposite, (n)ext
switch ( dir ) {
case '1' : case 'd' : // descending
dir = 1 ;
break ;
case 's' : // same direction (as primary column)
// if primary sort is set to 's', make it ascending
dir = primary || 0 ;
break ;
case 'o' :
2016-08-01 01:48:27 +00:00
temp = order [ ( primary || 0 ) % order . length ] ;
2015-10-18 18:21:11 +00:00
// opposite of primary column; but resets if primary resets
dir = temp === 0 ? 1 : temp === 1 ? 0 : 2 ;
break ;
case 'n' :
2016-08-01 01:48:27 +00:00
dir = order [ ( ++ c . sortVars [ col ] . count ) % order . length ] ;
2015-10-18 18:21:11 +00:00
break ;
default : // ascending
dir = 0 ;
break ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
primary = indx === 0 ? dir : primary ;
group = [ col , parseInt ( dir , 10 ) || 0 ] ;
2016-03-02 05:00:22 +00:00
c . sortList [ c . sortList . length ] = group ;
2015-10-21 16:03:14 +00:00
dir = $ . inArray ( group [ 1 ] , order ) ; // fixes issue #167
2016-08-01 01:48:27 +00:00
c . sortVars [ col ] . count = dir >= 0 ? dir : group [ 1 ] % order . length ;
2015-10-18 18:21:11 +00:00
}
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
updateAll : function ( c , resort , callback ) {
var table = c . table ;
table . isUpdating = true ;
ts . refreshWidgets ( table , true , true ) ;
ts . buildHeaders ( c ) ;
ts . bindEvents ( table , c . $headers , true ) ;
ts . bindMethods ( c ) ;
ts . commonUpdate ( c , resort , callback ) ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
update : function ( c , resort , callback ) {
var table = c . table ;
table . isUpdating = true ;
// update sorting (if enabled/disabled)
ts . updateHeader ( c ) ;
ts . commonUpdate ( c , resort , callback ) ;
} ,
// simple header update - see #989
updateHeaders : function ( c , callback ) {
c . table . isUpdating = true ;
ts . buildHeaders ( c ) ;
ts . bindEvents ( c . table , c . $headers , true ) ;
ts . resortComplete ( c , callback ) ;
} ,
updateCell : function ( c , cell , resort , callback ) {
2017-05-16 20:33:15 +00:00
// updateCell for child rows is a mess - we'll ignore them for now
// eventually I'll break out the "update" row cache code to make everything consistent
if ( $ ( cell ) . closest ( 'tr' ) . hasClass ( c . cssChildRow ) ) {
console . warn ( 'Tablesorter Warning! "updateCell" for child row content has been disabled, use "update" instead' ) ;
return ;
}
2015-12-13 22:24:42 +00:00
if ( ts . isEmptyObject ( c . cache ) ) {
// empty table, do an update instead - fixes #1099
ts . updateHeader ( c ) ;
ts . commonUpdate ( c , resort , callback ) ;
return ;
}
2015-10-18 18:21:11 +00:00
c . table . isUpdating = true ;
c . $table . find ( c . selectorRemove ) . remove ( ) ;
// get position from the dom
var tmp , indx , row , icell , cache , len ,
$tbodies = c . $tbodies ,
$cell = $ ( cell ) ,
// update cache - format: function( s, table, cell, cellIndex )
// no closest in jQuery v1.2.6
2017-09-28 02:07:28 +00:00
tbodyIndex = $tbodies . index ( ts . getClosest ( $cell , 'tbody' ) ) ,
2015-10-18 18:21:11 +00:00
tbcache = c . cache [ tbodyIndex ] ,
2017-09-28 02:07:28 +00:00
$row = ts . getClosest ( $cell , 'tr' ) ;
2015-10-18 18:21:11 +00:00
cell = $cell [ 0 ] ; // in case cell is a jQuery object
// tbody may not exist if update is initialized while tbody is removed for processing
if ( $tbodies . length && tbodyIndex >= 0 ) {
2017-04-07 09:53:12 +00:00
row = $tbodies . eq ( tbodyIndex ) . find ( 'tr' ) . not ( '.' + c . cssChildRow ) . index ( $row ) ;
2015-10-18 18:21:11 +00:00
cache = tbcache . normalized [ row ] ;
len = $row [ 0 ] . cells . length ;
if ( len !== c . columns ) {
// colspan in here somewhere!
icell = 0 ;
tmp = false ;
for ( indx = 0 ; indx < len ; indx ++ ) {
if ( ! tmp && $row [ 0 ] . cells [ indx ] !== cell ) {
icell += $row [ 0 ] . cells [ indx ] . colSpan ;
2015-07-24 23:23:00 +00:00
} else {
2015-10-18 18:21:11 +00:00
tmp = true ;
2015-07-24 23:23:00 +00:00
}
}
2015-03-28 20:03:50 +00:00
} else {
2015-10-18 18:21:11 +00:00
icell = $cell . index ( ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
tmp = ts . getElementText ( c , cell , icell ) ; // raw
cache [ c . columns ] . raw [ icell ] = tmp ;
tmp = ts . getParsedText ( c , cell , icell , tmp ) ;
cache [ icell ] = tmp ; // parsed
if ( ( c . parsers [ icell ] . type || '' ) . toLowerCase ( ) === 'numeric' ) {
// update column max value (ignore sign)
tbcache . colMax [ icell ] = Math . max ( Math . abs ( tmp ) || 0 , tbcache . colMax [ icell ] || 0 ) ;
}
tmp = resort !== 'undefined' ? resort : c . resort ;
if ( tmp !== false ) {
// widgets will be reapplied
ts . checkResort ( c , tmp , callback ) ;
2015-03-28 20:03:50 +00:00
} else {
2015-10-18 18:21:11 +00:00
// don't reapply widgets is resort is false, just in case it causes
// problems with element focus
ts . resortComplete ( c , callback ) ;
2015-03-28 20:03:50 +00:00
}
2015-12-02 19:36:47 +00:00
} else {
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2015-12-02 19:36:47 +00:00
console . error ( 'updateCell aborted, tbody missing or not within the indicated table' ) ;
}
c . table . isUpdating = false ;
2015-10-18 18:21:11 +00:00
}
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
addRows : function ( c , $row , resort , callback ) {
2016-03-02 05:00:22 +00:00
var txt , val , tbodyIndex , rowIndex , rows , cellIndex , len , order ,
2015-10-18 18:21:11 +00:00
cacheIndex , rowData , cells , cell , span ,
// allow passing a row string if only one non-info tbody exists in the table
valid = typeof $row === 'string' && c . $tbodies . length === 1 && /<tr/ . test ( $row || '' ) ,
table = c . table ;
if ( valid ) {
$row = $ ( $row ) ;
c . $tbodies . append ( $row ) ;
2017-09-28 02:07:28 +00:00
} else if (
! $row ||
2015-10-18 18:21:11 +00:00
// row is a jQuery object?
! ( $row instanceof jQuery ) ||
// row contained in the table?
2017-09-28 02:07:28 +00:00
( ts . getClosest ( $row , 'table' ) [ 0 ] !== c . table )
) {
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2015-10-18 18:21:11 +00:00
console . error ( 'addRows method requires (1) a jQuery selector reference to rows that have already ' +
'been added to the table, or (2) row HTML string to be added to a table with only one tbody' ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
return false ;
}
table . isUpdating = true ;
if ( ts . isEmptyObject ( c . cache ) ) {
// empty table, do an update instead - fixes #450
ts . updateHeader ( c ) ;
ts . commonUpdate ( c , resort , callback ) ;
} else {
rows = $row . filter ( 'tr' ) . attr ( 'role' , 'row' ) . length ;
tbodyIndex = c . $tbodies . index ( $row . parents ( 'tbody' ) . filter ( ':first' ) ) ;
// fixes adding rows to an empty table - see issue #179
if ( ! ( c . parsers && c . parsers . length ) ) {
ts . setupParsers ( c ) ;
}
// add each row
for ( rowIndex = 0 ; rowIndex < rows ; rowIndex ++ ) {
cacheIndex = 0 ;
len = $row [ rowIndex ] . cells . length ;
2016-03-02 05:00:22 +00:00
order = c . cache [ tbodyIndex ] . normalized . length ;
2015-10-18 18:21:11 +00:00
cells = [ ] ;
rowData = {
child : [ ] ,
raw : [ ] ,
$row : $row . eq ( rowIndex ) ,
2016-03-02 05:00:22 +00:00
order : order
2015-10-18 18:21:11 +00:00
} ;
// add each cell
for ( cellIndex = 0 ; cellIndex < len ; cellIndex ++ ) {
cell = $row [ rowIndex ] . cells [ cellIndex ] ;
txt = ts . getElementText ( c , cell , cacheIndex ) ;
rowData . raw [ cacheIndex ] = txt ;
val = ts . getParsedText ( c , cell , cacheIndex , txt ) ;
cells [ cacheIndex ] = val ;
if ( ( c . parsers [ cacheIndex ] . type || '' ) . toLowerCase ( ) === 'numeric' ) {
// update column max value (ignore sign)
c . cache [ tbodyIndex ] . colMax [ cacheIndex ] =
Math . max ( Math . abs ( val ) || 0 , c . cache [ tbodyIndex ] . colMax [ cacheIndex ] || 0 ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
span = cell . colSpan - 1 ;
if ( span > 0 ) {
cacheIndex += span ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
cacheIndex ++ ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
// add the row data to the end
cells [ c . columns ] = rowData ;
// update cache
2016-03-02 05:00:22 +00:00
c . cache [ tbodyIndex ] . normalized [ order ] = cells ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
// resort using current settings
ts . checkResort ( c , resort , callback ) ;
}
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
updateCache : function ( c , callback , $tbodies ) {
// rebuild parsers
if ( ! ( c . parsers && c . parsers . length ) ) {
ts . setupParsers ( c , $tbodies ) ;
}
// rebuild the cache map
ts . buildCache ( c , callback , $tbodies ) ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
// init flag (true) used by pager plugin to prevent widget application
// renamed from appendToTable
appendCache : function ( c , init ) {
var parsed , totalRows , $tbody , $curTbody , rowIndex , tbodyIndex , appendTime ,
table = c . table ,
$tbodies = c . $tbodies ,
rows = [ ] ,
cache = c . cache ;
// empty table - fixes #206/#346
if ( ts . isEmptyObject ( cache ) ) {
// run pager appender in case the table was just emptied
return c . appender ? c . appender ( table , rows ) :
2015-12-02 01:38:56 +00:00
table . isUpdating ? c . $table . triggerHandler ( 'updateComplete' , table ) : '' ; // Fixes #532
2015-10-18 18:21:11 +00:00
}
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2015-10-18 18:21:11 +00:00
appendTime = new Date ( ) ;
}
for ( tbodyIndex = 0 ; tbodyIndex < $tbodies . length ; tbodyIndex ++ ) {
$tbody = $tbodies . eq ( tbodyIndex ) ;
if ( $tbody . length ) {
// detach tbody for manipulation
$curTbody = ts . processTbody ( table , $tbody , true ) ;
parsed = cache [ tbodyIndex ] . normalized ;
totalRows = parsed . length ;
for ( rowIndex = 0 ; rowIndex < totalRows ; rowIndex ++ ) {
2016-03-02 05:00:22 +00:00
rows [ rows . length ] = parsed [ rowIndex ] [ c . columns ] . $row ;
2015-10-18 18:21:11 +00:00
// removeRows used by the pager plugin; don't render if using ajax - fixes #411
2018-03-18 13:49:07 +00:00
if ( ! c . appender || ( c . pager && ! c . pager . removeRows && ! c . pager . ajax ) ) {
2015-10-18 18:21:11 +00:00
$curTbody . append ( parsed [ rowIndex ] [ c . columns ] . $row ) ;
}
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
// restore tbody
ts . processTbody ( table , $curTbody , false ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
}
if ( c . appender ) {
c . appender ( table , rows ) ;
}
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2015-10-18 18:21:11 +00:00
console . log ( 'Rebuilt table' + ts . benchmark ( appendTime ) ) ;
}
// apply table widgets; but not before ajax completes
if ( ! init && ! c . appender ) {
ts . applyWidget ( table ) ;
}
if ( table . isUpdating ) {
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'updateComplete' , table ) ;
2015-10-18 18:21:11 +00:00
}
} ,
2015-07-29 23:38:55 +00:00
2015-10-18 18:21:11 +00:00
commonUpdate : function ( c , resort , callback ) {
// remove rows/elements before update
c . $table . find ( c . selectorRemove ) . remove ( ) ;
// rebuild parsers
ts . setupParsers ( c ) ;
// rebuild the cache map
ts . buildCache ( c ) ;
ts . checkResort ( c , resort , callback ) ;
} ,
2015-08-18 01:07:49 +00:00
2015-10-18 18:21:11 +00:00
/ *
▄ █ █ █ █ █ ▄ █ █ █ █ ▄ █ █ █ █ █ ▄ █ █ █ █ █ █ █ █ █ █ █ █ █ ▄ ▄ █ █ █ █ ▄
▀ █ ▄ █ █ █ █ █ █ ▄ ▄ █ █ █ █ █ █ █ █ █ █ █ █ ▄ ▄ ▄
▀ █ ▄ █ █ █ █ █ █ ▀ █ █ █ █ █ █ █ █ █ █ █ █ ▀ █ █
█ █ █ █ █ ▀ ▀ █ █ █ █ ▀ █ █ █ █ █ █ █ █ █ █ █ █ ▀ █ █ █ █ ▀
* /
initSort : function ( c , cell , event ) {
if ( c . table . isUpdating ) {
// let any updates complete before initializing a sort
2018-03-18 13:49:07 +00:00
return setTimeout ( function ( ) {
2015-10-18 18:21:11 +00:00
ts . initSort ( c , cell , event ) ;
} , 50 ) ;
}
2015-12-13 22:24:42 +00:00
2015-10-21 16:03:14 +00:00
var arry , indx , headerIndx , dir , temp , tmp , $header ,
2015-10-18 18:21:11 +00:00
notMultiSort = ! event [ c . sortMultiSortKey ] ,
2015-07-29 23:38:55 +00:00
table = c . table ,
2015-10-21 16:03:14 +00:00
len = c . $headers . length ,
2017-12-13 21:17:20 +00:00
th = ts . getClosest ( $ ( cell ) , 'th, td' ) ,
col = parseInt ( th . attr ( 'data-column' ) , 10 ) ,
2015-10-21 16:03:14 +00:00
order = c . sortVars [ col ] . order ;
2017-12-13 21:17:20 +00:00
th = th [ 0 ] ;
2015-10-18 18:21:11 +00:00
// Only call sortStart if sorting is enabled
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'sortStart' , table ) ;
2015-10-18 18:21:11 +00:00
// get current column sort order
2016-08-01 01:48:27 +00:00
tmp = ( c . sortVars [ col ] . count + 1 ) % order . length ;
c . sortVars [ col ] . count = event [ c . sortResetKey ] ? 2 : tmp ;
2015-10-18 18:21:11 +00:00
// reset all sorts on non-current column - issue #30
if ( c . sortRestart ) {
for ( headerIndx = 0 ; headerIndx < len ; headerIndx ++ ) {
$header = c . $headers . eq ( headerIndx ) ;
2015-11-06 19:41:19 +00:00
tmp = parseInt ( $header . attr ( 'data-column' ) , 10 ) ;
2015-10-18 18:21:11 +00:00
// only reset counts on columns that weren't just clicked on and if not included in a multisort
2015-11-06 19:41:19 +00:00
if ( col !== tmp && ( notMultiSort || $header . hasClass ( ts . css . sortNone ) ) ) {
c . sortVars [ tmp ] . count = - 1 ;
2015-07-29 23:38:55 +00:00
}
2015-10-18 18:21:11 +00:00
}
}
// user only wants to sort on one column
if ( notMultiSort ) {
// flush the sort list
c . sortList = [ ] ;
2015-10-20 17:47:05 +00:00
c . last . sortList = [ ] ;
2015-10-18 18:21:11 +00:00
if ( c . sortForce !== null ) {
arry = c . sortForce ;
2015-10-20 17:47:05 +00:00
for ( indx = 0 ; indx < arry . length ; indx ++ ) {
if ( arry [ indx ] [ 0 ] !== col ) {
2016-03-02 05:00:22 +00:00
c . sortList [ c . sortList . length ] = arry [ indx ] ;
2015-10-18 18:21:11 +00:00
}
2015-07-29 23:38:55 +00:00
}
}
2015-10-18 18:21:11 +00:00
// add column to sort list
2015-10-21 16:03:14 +00:00
dir = order [ c . sortVars [ col ] . count ] ;
2015-10-20 17:47:05 +00:00
if ( dir < 2 ) {
2016-03-02 05:00:22 +00:00
c . sortList [ c . sortList . length ] = [ col , dir ] ;
2015-10-18 18:21:11 +00:00
// add other columns if header spans across multiple
2017-12-13 21:17:20 +00:00
if ( th . colSpan > 1 ) {
for ( indx = 1 ; indx < th . colSpan ; indx ++ ) {
2016-03-02 05:00:22 +00:00
c . sortList [ c . sortList . length ] = [ col + indx , dir ] ;
2015-10-21 16:03:14 +00:00
// update count on columns in colSpan
c . sortVars [ col + indx ] . count = $ . inArray ( dir , order ) ;
2015-10-18 18:21:11 +00:00
}
2015-07-29 23:38:55 +00:00
}
}
2015-10-18 18:21:11 +00:00
// multi column sorting
} else {
// get rid of the sortAppend before adding more - fixes issue #115 & #523
2015-10-20 17:47:05 +00:00
c . sortList = $ . extend ( [ ] , c . last . sortList ) ;
2015-10-18 18:21:11 +00:00
// the user has clicked on an already sorted column
2015-10-20 17:47:05 +00:00
if ( ts . isValueInArray ( col , c . sortList ) >= 0 ) {
2015-10-18 18:21:11 +00:00
// reverse the sorting direction
2015-10-20 17:47:05 +00:00
for ( indx = 0 ; indx < c . sortList . length ; indx ++ ) {
tmp = c . sortList [ indx ] ;
2015-10-21 16:03:14 +00:00
if ( tmp [ 0 ] === col ) {
2015-10-18 18:21:11 +00:00
// order.count seems to be incorrect when compared to cell.count
2015-10-21 16:03:14 +00:00
tmp [ 1 ] = order [ c . sortVars [ col ] . count ] ;
2015-10-20 17:47:05 +00:00
if ( tmp [ 1 ] === 2 ) {
c . sortList . splice ( indx , 1 ) ;
2015-10-21 16:03:14 +00:00
c . sortVars [ col ] . count = - 1 ;
2015-07-29 23:38:55 +00:00
}
}
}
2015-10-18 18:21:11 +00:00
} else {
// add column to sort list array
2015-10-21 16:03:14 +00:00
dir = order [ c . sortVars [ col ] . count ] ;
2015-10-20 17:47:05 +00:00
if ( dir < 2 ) {
2016-03-02 05:00:22 +00:00
c . sortList [ c . sortList . length ] = [ col , dir ] ;
2015-10-18 18:21:11 +00:00
// add other columns if header spans across multiple
2017-12-13 21:17:20 +00:00
if ( th . colSpan > 1 ) {
for ( indx = 1 ; indx < th . colSpan ; indx ++ ) {
2016-03-02 05:00:22 +00:00
c . sortList [ c . sortList . length ] = [ col + indx , dir ] ;
2015-10-21 16:03:14 +00:00
// update count on columns in colSpan
c . sortVars [ col + indx ] . count = $ . inArray ( dir , order ) ;
2015-07-29 23:38:55 +00:00
}
}
}
}
2015-10-18 18:21:11 +00:00
}
2015-10-20 17:47:05 +00:00
// save sort before applying sortAppend
c . last . sortList = $ . extend ( [ ] , c . sortList ) ;
if ( c . sortList . length && c . sortAppend ) {
arry = $ . isArray ( c . sortAppend ) ? c . sortAppend : c . sortAppend [ c . sortList [ 0 ] [ 0 ] ] ;
if ( ! ts . isEmptyObject ( arry ) ) {
for ( indx = 0 ; indx < arry . length ; indx ++ ) {
if ( arry [ indx ] [ 0 ] !== col && ts . isValueInArray ( arry [ indx ] [ 0 ] , c . sortList ) < 0 ) {
dir = arry [ indx ] [ 1 ] ;
temp = ( '' + dir ) . match ( /^(a|d|s|o|n)/ ) ;
if ( temp ) {
tmp = c . sortList [ 0 ] [ 1 ] ;
switch ( temp [ 0 ] ) {
case 'd' :
dir = 1 ;
break ;
case 's' :
dir = tmp ;
break ;
case 'o' :
dir = tmp === 0 ? 1 : 0 ;
break ;
case 'n' :
2016-08-01 01:48:27 +00:00
dir = ( tmp + 1 ) % order . length ;
2015-10-20 17:47:05 +00:00
break ;
default :
dir = 0 ;
break ;
}
}
2016-03-02 05:00:22 +00:00
c . sortList [ c . sortList . length ] = [ arry [ indx ] [ 0 ] , dir ] ;
2015-10-20 17:47:05 +00:00
}
2015-10-18 18:21:11 +00:00
}
2015-07-29 23:38:55 +00:00
}
2015-10-18 18:21:11 +00:00
}
// sortBegin event triggered immediately before the sort
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'sortBegin' , table ) ;
2015-10-18 18:21:11 +00:00
// setTimeout needed so the processing icon shows up
setTimeout ( function ( ) {
2015-07-29 23:38:55 +00:00
// set css for headers
2015-10-18 18:21:11 +00:00
ts . setHeadersCss ( c ) ;
ts . multisort ( c ) ;
ts . appendCache ( c ) ;
2015-12-13 22:24:42 +00:00
c . $table . triggerHandler ( 'sortBeforeEnd' , table ) ;
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'sortEnd' , table ) ;
2015-10-18 18:21:11 +00:00
} , 1 ) ;
} ,
2015-07-29 23:38:55 +00:00
2015-10-18 18:21:11 +00:00
// sort multiple columns
multisort : function ( c ) { /*jshint loopfunc:true */
2016-09-01 16:46:28 +00:00
var tbodyIndex , sortTime , colMax , rows , tmp ,
2015-10-18 18:21:11 +00:00
table = c . table ,
2016-09-01 16:46:28 +00:00
sorter = [ ] ,
2015-10-18 18:21:11 +00:00
dir = 0 ,
textSorter = c . textSorter || '' ,
sortList = c . sortList ,
sortLen = sortList . length ,
len = c . $tbodies . length ;
if ( c . serverSideSorting || ts . isEmptyObject ( c . cache ) ) {
// empty table - fixes #206/#346
return ;
}
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) { sortTime = new Date ( ) ; }
2016-09-01 16:46:28 +00:00
// cache textSorter to optimize speed
if ( typeof textSorter === 'object' ) {
colMax = c . columns ;
while ( colMax -- ) {
tmp = ts . getColumnData ( table , textSorter , colMax ) ;
if ( typeof tmp === 'function' ) {
sorter [ colMax ] = tmp ;
}
}
}
2015-10-18 18:21:11 +00:00
for ( tbodyIndex = 0 ; tbodyIndex < len ; tbodyIndex ++ ) {
colMax = c . cache [ tbodyIndex ] . colMax ;
rows = c . cache [ tbodyIndex ] . normalized ;
rows . sort ( function ( a , b ) {
var sortIndex , num , col , order , sort , x , y ;
// rows is undefined here in IE, so don't use it!
for ( sortIndex = 0 ; sortIndex < sortLen ; sortIndex ++ ) {
col = sortList [ sortIndex ] [ 0 ] ;
order = sortList [ sortIndex ] [ 1 ] ;
// sort direction, true = asc, false = desc
dir = order === 0 ;
if ( c . sortStable && a [ col ] === b [ col ] && sortLen === 1 ) {
return a [ c . columns ] . order - b [ c . columns ] . order ;
}
// fallback to natural sort since it is more robust
num = /n/i . test ( ts . getSortType ( c . parsers , col ) ) ;
if ( num && c . strings [ col ] ) {
// sort strings in numerical columns
if ( typeof ( ts . string [ c . strings [ col ] ] ) === 'boolean' ) {
num = ( dir ? 1 : - 1 ) * ( ts . string [ c . strings [ col ] ] ? - 1 : 1 ) ;
} else {
num = ( c . strings [ col ] ) ? ts . string [ c . strings [ col ] ] || 0 : 0 ;
}
// fall back to built-in numeric sort
// var sort = $.tablesorter['sort' + s]( a[col], b[col], dir, colMax[col], table );
sort = c . numberSorter ? c . numberSorter ( a [ col ] , b [ col ] , dir , colMax [ col ] , table ) :
ts [ 'sortNumeric' + ( dir ? 'Asc' : 'Desc' ) ] ( a [ col ] , b [ col ] , num , colMax [ col ] , col , c ) ;
} else {
// set a & b depending on sort direction
x = dir ? a : b ;
y = dir ? b : a ;
// text sort function
if ( typeof textSorter === 'function' ) {
// custom OVERALL text sorter
sort = textSorter ( x [ col ] , y [ col ] , dir , col , table ) ;
2016-09-01 16:46:28 +00:00
} else if ( typeof sorter [ col ] === 'function' ) {
2015-10-18 18:21:11 +00:00
// custom text sorter for a SPECIFIC COLUMN
2016-09-01 16:46:28 +00:00
sort = sorter [ col ] ( x [ col ] , y [ col ] , dir , col , table ) ;
2015-10-18 18:21:11 +00:00
} else {
// fall back to natural sort
sort = ts [ 'sortNatural' + ( dir ? 'Asc' : 'Desc' ) ] ( a [ col ] , b [ col ] , col , c ) ;
}
}
if ( sort ) { return sort ; }
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
return a [ c . columns ] . order - b [ c . columns ] . order ;
} ) ;
}
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2015-10-18 18:21:11 +00:00
console . log ( 'Applying sort ' + sortList . toString ( ) + ts . benchmark ( sortTime ) ) ;
}
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
resortComplete : function ( c , callback ) {
if ( c . table . isUpdating ) {
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'updateComplete' , c . table ) ;
2015-10-18 18:21:11 +00:00
}
if ( $ . isFunction ( callback ) ) {
callback ( c . table ) ;
}
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
checkResort : function ( c , resort , callback ) {
var sortList = $ . isArray ( resort ) ? resort : c . sortList ,
// if no resort parameter is passed, fallback to config.resort (true by default)
resrt = typeof resort === 'undefined' ? c . resort : resort ;
// don't try to resort if the table is still processing
// this will catch spamming of the updateCell method
if ( resrt !== false && ! c . serverSideSorting && ! c . table . isProcessing ) {
if ( sortList . length ) {
2015-10-22 21:41:34 +00:00
ts . sortOn ( c , sortList , function ( ) {
2015-10-18 18:21:11 +00:00
ts . resortComplete ( c , callback ) ;
2015-10-22 21:41:34 +00:00
} , true ) ;
2015-10-18 18:21:11 +00:00
} else {
2015-10-22 21:41:34 +00:00
ts . sortReset ( c , function ( ) {
2015-10-18 18:21:11 +00:00
ts . resortComplete ( c , callback ) ;
ts . applyWidget ( c . table , false ) ;
2015-10-22 21:41:34 +00:00
} ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
} else {
ts . resortComplete ( c , callback ) ;
ts . applyWidget ( c . table , false ) ;
}
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
sortOn : function ( c , list , callback , init ) {
var table = c . table ;
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'sortStart' , table ) ;
2015-10-18 18:21:11 +00:00
// update header count index
ts . updateHeaderSortCount ( c , list ) ;
// set css for headers
ts . setHeadersCss ( c ) ;
// fixes #346
if ( c . delayInit && ts . isEmptyObject ( c . cache ) ) {
ts . buildCache ( c ) ;
}
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'sortBegin' , table ) ;
2015-10-18 18:21:11 +00:00
// sort the table and append it to the dom
ts . multisort ( c ) ;
ts . appendCache ( c , init ) ;
2015-12-13 22:24:42 +00:00
c . $table . triggerHandler ( 'sortBeforeEnd' , table ) ;
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'sortEnd' , table ) ;
2015-10-18 18:21:11 +00:00
ts . applyWidget ( table ) ;
if ( $ . isFunction ( callback ) ) {
callback ( table ) ;
}
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
sortReset : function ( c , callback ) {
c . sortList = [ ] ;
ts . setHeadersCss ( c ) ;
ts . multisort ( c ) ;
ts . appendCache ( c ) ;
2017-04-02 11:33:20 +00:00
var indx ;
for ( indx = 0 ; indx < c . columns ; indx ++ ) {
c . sortVars [ indx ] . count = - 1 ;
}
2015-10-18 18:21:11 +00:00
if ( $ . isFunction ( callback ) ) {
callback ( c . table ) ;
}
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
getSortType : function ( parsers , column ) {
return ( parsers && parsers [ column ] ) ? parsers [ column ] . type || '' : '' ;
} ,
2015-03-28 20:03:50 +00:00
2015-12-13 22:24:42 +00:00
getOrder : function ( val ) {
2015-10-18 18:21:11 +00:00
// look for 'd' in 'desc' order; return true
return ( /^d/i . test ( val ) || val === 1 ) ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
// Natural sort - https://github.com/overset/javascript-natural-sort (date sorting removed)
sortNatural : function ( a , b ) {
if ( a === b ) { return 0 ; }
2017-06-02 22:49:41 +00:00
a = a . toString ( ) ;
b = b . toString ( ) ;
2015-10-18 18:21:11 +00:00
var aNum , bNum , aFloat , bFloat , indx , max ,
regex = ts . regex ;
// first try and sort Hex codes
if ( regex . hex . test ( b ) ) {
2016-07-11 12:42:19 +00:00
aNum = parseInt ( ( a || '' ) . match ( regex . hex ) , 16 ) ;
bNum = parseInt ( ( b || '' ) . match ( regex . hex ) , 16 ) ;
2015-10-18 18:21:11 +00:00
if ( aNum < bNum ) { return - 1 ; }
if ( aNum > bNum ) { return 1 ; }
}
// chunk/tokenize
2016-07-11 12:42:19 +00:00
aNum = ( a || '' ) . replace ( regex . chunk , '\\0$1\\0' ) . replace ( regex . chunks , '' ) . split ( '\\0' ) ;
bNum = ( b || '' ) . replace ( regex . chunk , '\\0$1\\0' ) . replace ( regex . chunks , '' ) . split ( '\\0' ) ;
2015-10-18 18:21:11 +00:00
max = Math . max ( aNum . length , bNum . length ) ;
// natural sorting through split numeric strings and default strings
for ( indx = 0 ; indx < max ; indx ++ ) {
// find floats not starting with '0', string or 0 if not defined
aFloat = isNaN ( aNum [ indx ] ) ? aNum [ indx ] || 0 : parseFloat ( aNum [ indx ] ) || 0 ;
bFloat = isNaN ( bNum [ indx ] ) ? bNum [ indx ] || 0 : parseFloat ( bNum [ indx ] ) || 0 ;
// handle numeric vs string comparison - number < string - (Kyle Adams)
if ( isNaN ( aFloat ) !== isNaN ( bFloat ) ) { return isNaN ( aFloat ) ? 1 : - 1 ; }
// rely on string comparison if different types - i.e. '02' < 2 != '02' < '2'
if ( typeof aFloat !== typeof bFloat ) {
aFloat += '' ;
bFloat += '' ;
}
if ( aFloat < bFloat ) { return - 1 ; }
if ( aFloat > bFloat ) { return 1 ; }
}
return 0 ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
sortNaturalAsc : function ( a , b , col , c ) {
if ( a === b ) { return 0 ; }
var empty = ts . string [ ( c . empties [ col ] || c . emptyTo ) ] ;
if ( a === '' && empty !== 0 ) { return typeof empty === 'boolean' ? ( empty ? - 1 : 1 ) : - empty || - 1 ; }
if ( b === '' && empty !== 0 ) { return typeof empty === 'boolean' ? ( empty ? 1 : - 1 ) : empty || 1 ; }
return ts . sortNatural ( a , b ) ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
sortNaturalDesc : function ( a , b , col , c ) {
if ( a === b ) { return 0 ; }
var empty = ts . string [ ( c . empties [ col ] || c . emptyTo ) ] ;
if ( a === '' && empty !== 0 ) { return typeof empty === 'boolean' ? ( empty ? - 1 : 1 ) : empty || 1 ; }
if ( b === '' && empty !== 0 ) { return typeof empty === 'boolean' ? ( empty ? 1 : - 1 ) : - empty || - 1 ; }
return ts . sortNatural ( b , a ) ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
// basic alphabetical sort
sortText : function ( a , b ) {
return a > b ? 1 : ( a < b ? - 1 : 0 ) ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
// return text string value by adding up ascii value
// so the text is somewhat sorted when using a digital sort
// this is NOT an alphanumeric sort
getTextValue : function ( val , num , max ) {
if ( max ) {
// make sure the text value is greater than the max numerical value (max)
2015-07-26 17:17:22 +00:00
var indx ,
2015-10-18 18:21:11 +00:00
len = val ? val . length : 0 ,
n = max + num ;
2015-07-26 17:17:22 +00:00
for ( indx = 0 ; indx < len ; indx ++ ) {
2015-10-18 18:21:11 +00:00
n += val . charCodeAt ( indx ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
return num * n ;
}
return 0 ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
sortNumericAsc : function ( a , b , num , max , col , c ) {
if ( a === b ) { return 0 ; }
var empty = ts . string [ ( c . empties [ col ] || c . emptyTo ) ] ;
if ( a === '' && empty !== 0 ) { return typeof empty === 'boolean' ? ( empty ? - 1 : 1 ) : - empty || - 1 ; }
if ( b === '' && empty !== 0 ) { return typeof empty === 'boolean' ? ( empty ? 1 : - 1 ) : empty || 1 ; }
if ( isNaN ( a ) ) { a = ts . getTextValue ( a , num , max ) ; }
if ( isNaN ( b ) ) { b = ts . getTextValue ( b , num , max ) ; }
return a - b ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
sortNumericDesc : function ( a , b , num , max , col , c ) {
if ( a === b ) { return 0 ; }
var empty = ts . string [ ( c . empties [ col ] || c . emptyTo ) ] ;
if ( a === '' && empty !== 0 ) { return typeof empty === 'boolean' ? ( empty ? - 1 : 1 ) : empty || 1 ; }
if ( b === '' && empty !== 0 ) { return typeof empty === 'boolean' ? ( empty ? 1 : - 1 ) : - empty || - 1 ; }
if ( isNaN ( a ) ) { a = ts . getTextValue ( a , num , max ) ; }
if ( isNaN ( b ) ) { b = ts . getTextValue ( b , num , max ) ; }
return b - a ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
sortNumeric : function ( a , b ) {
return a - b ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
/ *
█ █ █ █ █ █ █ █ █ █ █ █ █ ▄ ▄ █ █ █ █ ▄ █ █ █ █ █ █ █ █ █ █ █ █ ▄ █ █ █ █ █
█ █ █ █ █ █ █ █ █ █ █ █ █ █ ▄ ▄ ▄ █ █ ▄ ▄ █ █ ▀ █ ▄
█ █ █ █ █ █ █ █ █ █ █ █ █ █ ▀ █ █ █ █ ▀ ▀ █ █ ▀ █ ▄
█ █ █ █ █ █ █ ▀ █ █ █ █ █ █ █ ▀ ▀ █ █ █ █ ▀ █ █ █ █ █ █ █ █ █ █ █ █ █ ▀
* /
addWidget : function ( widget ) {
2016-03-18 15:38:01 +00:00
if ( widget . id && ! ts . isEmptyObject ( ts . getWidgetById ( widget . id ) ) ) {
console . warn ( '"' + widget . id + '" widget was loaded more than once!' ) ;
}
2016-03-02 05:00:22 +00:00
ts . widgets [ ts . widgets . length ] = widget ;
2015-10-18 18:21:11 +00:00
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
hasWidget : function ( $table , name ) {
$table = $ ( $table ) ;
return $table . length && $table [ 0 ] . config && $table [ 0 ] . config . widgetInit [ name ] || false ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
getWidgetById : function ( name ) {
var indx , widget ,
len = ts . widgets . length ;
for ( indx = 0 ; indx < len ; indx ++ ) {
widget = ts . widgets [ indx ] ;
if ( widget && widget . id && widget . id . toLowerCase ( ) === name . toLowerCase ( ) ) {
return widget ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
}
} ,
2015-03-28 20:03:50 +00:00
2015-10-31 15:08:21 +00:00
applyWidgetOptions : function ( table ) {
2017-04-02 11:33:20 +00:00
var indx , widget , wo ,
2015-10-31 15:08:21 +00:00
c = table . config ,
2015-10-18 18:21:11 +00:00
len = c . widgets . length ;
if ( len ) {
for ( indx = 0 ; indx < len ; indx ++ ) {
widget = ts . getWidgetById ( c . widgets [ indx ] ) ;
if ( widget && widget . options ) {
2017-05-03 22:22:27 +00:00
wo = $ . extend ( true , { } , widget . options ) ;
2017-04-02 11:33:20 +00:00
c . widgetOptions = $ . extend ( true , wo , c . widgetOptions ) ;
2016-11-27 01:40:00 +00:00
// add widgetOptions to defaults for option validator
$ . extend ( true , ts . defaults . widgetOptions , widget . options ) ;
2015-03-28 20:03:50 +00:00
}
}
2015-10-18 18:21:11 +00:00
}
} ,
2015-03-28 20:03:50 +00:00
2015-10-31 15:08:21 +00:00
addWidgetFromClass : function ( table ) {
var len , indx ,
c = table . config ,
// look for widgets to apply from table class
2016-01-11 04:22:16 +00:00
// don't match from 'ui-widget-content'; use \S instead of \w to include widgets
// with dashes in the name, e.g. "widget-test-2" extracts out "test-2"
regex = '^' + c . widgetClass . replace ( ts . regex . templateName , '(\\S+)+' ) + '$' ,
2015-10-31 15:08:21 +00:00
widgetClass = new RegExp ( regex , 'g' ) ,
2016-01-11 04:22:16 +00:00
// split up table class (widget id's can include dashes) - stop using match
// otherwise only one widget gets extracted, see #1109
widgets = ( table . className || '' ) . split ( ts . regex . spaces ) ;
if ( widgets . length ) {
len = widgets . length ;
2015-10-31 15:08:21 +00:00
for ( indx = 0 ; indx < len ; indx ++ ) {
2016-01-11 04:22:16 +00:00
if ( widgets [ indx ] . match ( widgetClass ) ) {
2016-03-02 05:00:22 +00:00
c . widgets [ c . widgets . length ] = widgets [ indx ] . replace ( widgetClass , '$1' ) ;
2016-01-11 04:22:16 +00:00
}
2015-10-31 15:08:21 +00:00
}
}
} ,
2015-12-13 22:24:42 +00:00
applyWidgetId : function ( table , id , init ) {
2016-02-15 19:15:22 +00:00
table = $ ( table ) [ 0 ] ;
2015-12-13 22:24:42 +00:00
var applied , time , name ,
c = table . config ,
wo = c . widgetOptions ,
2018-03-18 13:49:07 +00:00
debug = ts . debug ( c , 'core' ) ,
2015-12-13 22:24:42 +00:00
widget = ts . getWidgetById ( id ) ;
if ( widget ) {
name = widget . id ;
applied = false ;
// add widget name to option list so it gets reapplied after sorting, filtering, etc
if ( $ . inArray ( name , c . widgets ) < 0 ) {
2016-03-02 05:00:22 +00:00
c . widgets [ c . widgets . length ] = name ;
2015-12-13 22:24:42 +00:00
}
2018-03-18 13:49:07 +00:00
if ( debug ) { time = new Date ( ) ; }
2015-12-13 22:24:42 +00:00
if ( init || ! ( c . widgetInit [ name ] ) ) {
// set init flag first to prevent calling init more than once (e.g. pager)
c . widgetInit [ name ] = true ;
if ( table . hasInitialized ) {
// don't reapply widget options on tablesorter init
ts . applyWidgetOptions ( table ) ;
}
if ( typeof widget . init === 'function' ) {
applied = true ;
2018-03-18 13:49:07 +00:00
if ( debug ) {
2015-12-13 22:24:42 +00:00
console [ console . group ? 'group' : 'log' ] ( 'Initializing ' + name + ' widget' ) ;
}
widget . init ( table , widget , c , wo ) ;
}
}
if ( ! init && typeof widget . format === 'function' ) {
applied = true ;
2018-03-18 13:49:07 +00:00
if ( debug ) {
2015-12-13 22:24:42 +00:00
console [ console . group ? 'group' : 'log' ] ( 'Updating ' + name + ' widget' ) ;
}
widget . format ( table , c , wo , false ) ;
}
2018-03-18 13:49:07 +00:00
if ( debug ) {
2015-12-13 22:24:42 +00:00
if ( applied ) {
console . log ( 'Completed ' + ( init ? 'initializing ' : 'applying ' ) + name + ' widget' + ts . benchmark ( time ) ) ;
if ( console . groupEnd ) { console . groupEnd ( ) ; }
}
}
}
} ,
2015-10-18 18:21:11 +00:00
applyWidget : function ( table , init , callback ) {
table = $ ( table ) [ 0 ] ; // in case this is called externally
2015-12-13 22:24:42 +00:00
var indx , len , names , widget , time ,
2015-10-18 18:21:11 +00:00
c = table . config ,
2018-03-18 13:49:07 +00:00
debug = ts . debug ( c , 'core' ) ,
2015-10-18 18:21:11 +00:00
widgets = [ ] ;
// prevent numerous consecutive widget applications
if ( init !== false && table . hasInitialized && ( table . isApplyingWidgets || table . isUpdating ) ) {
return ;
}
2018-03-18 13:49:07 +00:00
if ( debug ) { time = new Date ( ) ; }
2015-10-31 15:08:21 +00:00
ts . addWidgetFromClass ( table ) ;
2015-11-15 04:26:08 +00:00
// prevent "tablesorter-ready" from firing multiple times in a row
clearTimeout ( c . timerReady ) ;
2015-10-18 18:21:11 +00:00
if ( c . widgets . length ) {
table . isApplyingWidgets = true ;
// ensure unique widget ids
c . widgets = $ . grep ( c . widgets , function ( val , index ) {
return $ . inArray ( val , c . widgets ) === index ;
} ) ;
names = c . widgets || [ ] ;
len = names . length ;
// build widget array & add priority as needed
for ( indx = 0 ; indx < len ; indx ++ ) {
widget = ts . getWidgetById ( names [ indx ] ) ;
if ( widget && widget . id ) {
// set priority to 10 if not defined
if ( ! widget . priority ) { widget . priority = 10 ; }
widgets [ indx ] = widget ;
2018-03-18 13:49:07 +00:00
} else if ( debug ) {
2017-09-28 02:07:28 +00:00
console . warn ( '"' + names [ indx ] + '" was enabled, but the widget code has not been loaded!' ) ;
2015-07-24 23:23:00 +00:00
}
2015-10-18 18:21:11 +00:00
}
// sort widgets by priority
widgets . sort ( function ( a , b ) {
return a . priority < b . priority ? - 1 : a . priority === b . priority ? 0 : 1 ;
} ) ;
// add/update selected widgets
len = widgets . length ;
2018-03-18 13:49:07 +00:00
if ( debug ) {
2015-10-18 18:21:11 +00:00
console [ console . group ? 'group' : 'log' ] ( 'Start ' + ( init ? 'initializing' : 'applying' ) + ' widgets' ) ;
}
for ( indx = 0 ; indx < len ; indx ++ ) {
widget = widgets [ indx ] ;
2015-12-13 22:24:42 +00:00
if ( widget && widget . id ) {
ts . applyWidgetId ( table , widget . id , init ) ;
2015-03-28 20:03:50 +00:00
}
}
2018-03-18 13:49:07 +00:00
if ( debug && console . groupEnd ) { console . groupEnd ( ) ; }
2015-10-18 18:21:11 +00:00
}
2015-11-15 04:26:08 +00:00
c . timerReady = setTimeout ( function ( ) {
2015-10-18 18:21:11 +00:00
table . isApplyingWidgets = false ;
$ . data ( table , 'lastWidgetApplication' , new Date ( ) ) ;
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'tablesorter-ready' ) ;
2017-04-02 11:33:20 +00:00
// callback executed on init only
if ( ! init && typeof callback === 'function' ) {
callback ( table ) ;
}
2018-03-18 13:49:07 +00:00
if ( debug ) {
2017-04-02 11:33:20 +00:00
widget = c . widgets . length ;
console . log ( 'Completed ' +
( init === true ? 'initializing ' : 'applying ' ) + widget +
' widget' + ( widget !== 1 ? 's' : '' ) + ts . benchmark ( time ) ) ;
}
2015-11-15 04:26:08 +00:00
} , 10 ) ;
2015-10-18 18:21:11 +00:00
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
removeWidget : function ( table , name , refreshing ) {
table = $ ( table ) [ 0 ] ;
var index , widget , indx , len ,
c = table . config ;
// if name === true, add all widgets from $.tablesorter.widgets
if ( name === true ) {
name = [ ] ;
len = ts . widgets . length ;
for ( indx = 0 ; indx < len ; indx ++ ) {
widget = ts . widgets [ indx ] ;
if ( widget && widget . id ) {
2016-03-02 05:00:22 +00:00
name [ name . length ] = widget . id ;
2015-03-28 20:03:50 +00:00
}
}
2015-10-18 18:21:11 +00:00
} else {
// name can be either an array of widgets names,
// or a space/comma separated list of widget names
name = ( $ . isArray ( name ) ? name . join ( ',' ) : name || '' ) . toLowerCase ( ) . split ( /[\s,]+/ ) ;
}
len = name . length ;
for ( index = 0 ; index < len ; index ++ ) {
widget = ts . getWidgetById ( name [ index ] ) ;
indx = $ . inArray ( name [ index ] , c . widgets ) ;
2016-02-15 19:15:22 +00:00
// don't remove the widget from config.widget if refreshing
if ( indx >= 0 && refreshing !== true ) {
c . widgets . splice ( indx , 1 ) ;
}
2015-10-18 18:21:11 +00:00
if ( widget && widget . remove ) {
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2015-10-18 18:21:11 +00:00
console . log ( ( refreshing ? 'Refreshing' : 'Removing' ) + ' "' + name [ index ] + '" widget' ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
widget . remove ( table , c , c . widgetOptions , refreshing ) ;
c . widgetInit [ name [ index ] ] = false ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
}
2017-09-28 02:07:28 +00:00
c . $table . triggerHandler ( 'widgetRemoveEnd' , table ) ;
2015-10-18 18:21:11 +00:00
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
refreshWidgets : function ( table , doAll , dontapply ) {
table = $ ( table ) [ 0 ] ; // see issue #243
var indx , widget ,
c = table . config ,
curWidgets = c . widgets ,
widgets = ts . widgets ,
len = widgets . length ,
list = [ ] ,
callback = function ( table ) {
2015-12-02 01:38:56 +00:00
$ ( table ) . triggerHandler ( 'refreshComplete' ) ;
2015-10-18 18:21:11 +00:00
} ;
// remove widgets not defined in config.widgets, unless doAll is true
for ( indx = 0 ; indx < len ; indx ++ ) {
widget = widgets [ indx ] ;
if ( widget && widget . id && ( doAll || $ . inArray ( widget . id , curWidgets ) < 0 ) ) {
2016-03-02 05:00:22 +00:00
list [ list . length ] = widget . id ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
}
ts . removeWidget ( table , list . join ( ',' ) , true ) ;
if ( dontapply !== true ) {
// call widget init if
ts . applyWidget ( table , doAll || false , callback ) ;
if ( doAll ) {
// apply widget format
ts . applyWidget ( table , false , callback ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
} else {
callback ( table ) ;
}
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
/ *
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ ▄ █ █ █ █ █
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ ▄ ▄ ▀ █ ▄
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ ▀ ▀ ▀ █ ▄
▀ █ █ █ █ ▀ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ ▀
* /
benchmark : function ( diff ) {
2016-08-01 01:48:27 +00:00
return ( ' (' + ( new Date ( ) . getTime ( ) - diff . getTime ( ) ) + ' ms)' ) ;
2015-10-18 18:21:11 +00:00
} ,
// deprecated ts.log
log : function ( ) {
console . log ( arguments ) ;
} ,
2018-03-18 13:49:07 +00:00
debug : function ( c , name ) {
return c && (
c . debug === true ||
typeof c . debug === 'string' && c . debug . indexOf ( name ) > - 1
) ;
} ,
2015-10-18 18:21:11 +00:00
// $.isEmptyObject from jQuery v1.4
isEmptyObject : function ( obj ) {
/*jshint forin: false */
for ( var name in obj ) {
return false ;
}
return true ;
} ,
isValueInArray : function ( column , arry ) {
var indx ,
len = arry && arry . length || 0 ;
for ( indx = 0 ; indx < len ; indx ++ ) {
if ( arry [ indx ] [ 0 ] === column ) {
return indx ;
}
}
return - 1 ;
} ,
formatFloat : function ( str , table ) {
if ( typeof str !== 'string' || str === '' ) { return str ; }
// allow using formatFloat without a table; defaults to US number format
var num ,
usFormat = table && table . config ? table . config . usNumberFormat !== false :
typeof table !== 'undefined' ? table : true ;
if ( usFormat ) {
// US Format - 1,234,567.89 -> 1234567.89
str = str . replace ( ts . regex . comma , '' ) ;
} else {
// German Format = 1.234.567,89 -> 1234567.89
// French Format = 1 234 567,89 -> 1234567.89
str = str . replace ( ts . regex . digitNonUS , '' ) . replace ( ts . regex . comma , '.' ) ;
}
if ( ts . regex . digitNegativeTest . test ( str ) ) {
// make (#) into a negative number -> (10) = -10
str = str . replace ( ts . regex . digitNegativeReplace , '-$1' ) ;
}
num = parseFloat ( str ) ;
// return the text instead of zero
return isNaN ( num ) ? $ . trim ( str ) : num ;
} ,
isDigit : function ( str ) {
// replace all unwanted chars and match
return isNaN ( str ) ?
ts . regex . digitTest . test ( str . toString ( ) . replace ( ts . regex . digitReplace , '' ) ) :
str !== '' ;
} ,
// computeTableHeaderCellIndexes from:
// http://www.javascripttoolbox.com/lib/table/examples.php
// http://www.javascripttoolbox.com/temp/table_cellindex.html
2015-12-13 22:24:42 +00:00
computeColumnIndex : function ( $rows , c ) {
var i , j , k , l , cell , cells , rowIndex , rowSpan , colSpan , firstAvailCol ,
// total columns has been calculated, use it to set the matrixrow
columns = c && c . columns || 0 ,
2015-10-18 18:21:11 +00:00
matrix = [ ] ,
2015-12-13 22:24:42 +00:00
matrixrow = new Array ( columns ) ;
2015-10-18 18:21:11 +00:00
for ( i = 0 ; i < $rows . length ; i ++ ) {
cells = $rows [ i ] . cells ;
for ( j = 0 ; j < cells . length ; j ++ ) {
cell = cells [ j ] ;
2017-07-04 17:56:45 +00:00
rowIndex = i ;
2015-10-18 18:21:11 +00:00
rowSpan = cell . rowSpan || 1 ;
colSpan = cell . colSpan || 1 ;
if ( typeof matrix [ rowIndex ] === 'undefined' ) {
matrix [ rowIndex ] = [ ] ;
2015-07-24 23:23:00 +00:00
}
2015-10-18 18:21:11 +00:00
// Find first available column in the first row
for ( k = 0 ; k < matrix [ rowIndex ] . length + 1 ; k ++ ) {
if ( typeof matrix [ rowIndex ] [ k ] === 'undefined' ) {
firstAvailCol = k ;
break ;
}
}
2015-12-13 22:24:42 +00:00
// jscs:disable disallowEmptyBlocks
if ( columns && cell . cellIndex === firstAvailCol ) {
// don't to anything
} else if ( cell . setAttribute ) {
// jscs:enable disallowEmptyBlocks
// add data-column (setAttribute = IE8+)
2015-10-27 22:01:07 +00:00
cell . setAttribute ( 'data-column' , firstAvailCol ) ;
} else {
2015-12-13 22:24:42 +00:00
// remove once we drop support for IE7 - 1/12/2016
$ ( cell ) . attr ( 'data-column' , firstAvailCol ) ;
2015-10-27 22:01:07 +00:00
}
2015-10-18 18:21:11 +00:00
for ( k = rowIndex ; k < rowIndex + rowSpan ; k ++ ) {
if ( typeof matrix [ k ] === 'undefined' ) {
matrix [ k ] = [ ] ;
}
matrixrow = matrix [ k ] ;
for ( l = firstAvailCol ; l < firstAvailCol + colSpan ; l ++ ) {
matrixrow [ l ] = 'x' ;
2015-03-28 21:50:52 +00:00
}
}
}
2015-10-18 18:21:11 +00:00
}
2017-06-09 00:26:53 +00:00
ts . checkColumnCount ( $rows , matrix , matrixrow . length ) ;
2015-10-18 18:21:11 +00:00
return matrixrow . length ;
} ,
2015-03-28 21:50:52 +00:00
2017-06-09 00:26:53 +00:00
checkColumnCount : function ( $rows , matrix , columns ) {
// this DOES NOT report any tbody column issues, except for the math and
// and column selector widgets
var i , len ,
valid = true ,
cells = [ ] ;
for ( i = 0 ; i < matrix . length ; i ++ ) {
// some matrix entries are undefined when testing the footer because
// it is using the rowIndex property
if ( matrix [ i ] ) {
len = matrix [ i ] . length ;
if ( matrix [ i ] . length !== columns ) {
valid = false ;
break ;
}
}
}
if ( ! valid ) {
$rows . each ( function ( indx , el ) {
var cell = el . parentElement . nodeName ;
2017-07-04 17:56:45 +00:00
if ( cells . indexOf ( cell ) < 0 ) {
2017-06-09 00:26:53 +00:00
cells . push ( cell ) ;
}
} ) ;
console . error (
'Invalid or incorrect number of columns in the ' +
cells . join ( ' or ' ) + '; expected ' + columns +
', but found ' + len + ' columns'
) ;
}
} ,
2015-10-18 18:21:11 +00:00
// automatically add a colgroup with col elements set to a percentage width
fixColumnWidth : function ( table ) {
table = $ ( table ) [ 0 ] ;
var overallWidth , percent , $tbodies , len , index ,
c = table . config ,
$colgroup = c . $table . children ( 'colgroup' ) ;
// remove plugin-added colgroup, in case we need to refresh the widths
if ( $colgroup . length && $colgroup . hasClass ( ts . css . colgroup ) ) {
$colgroup . remove ( ) ;
}
if ( c . widthFixed && c . $table . children ( 'colgroup' ) . length === 0 ) {
$colgroup = $ ( '<colgroup class="' + ts . css . colgroup + '">' ) ;
overallWidth = c . $table . width ( ) ;
// only add col for visible columns - fixes #371
$tbodies = c . $tbodies . find ( 'tr:first' ) . children ( ':visible' ) ;
len = $tbodies . length ;
for ( index = 0 ; index < len ; index ++ ) {
percent = parseInt ( ( $tbodies . eq ( index ) . width ( ) / overallWidth ) * 1000 , 10 ) / 10 + '%' ;
$colgroup . append ( $ ( '<col>' ) . css ( 'width' , percent ) ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
c . $table . prepend ( $colgroup ) ;
}
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
// get sorter, string, empty, etc options for each column from
// jQuery data, metadata, header option or header class name ('sorter-false')
// priority = jQuery data > meta > headers option > header class name
getData : function ( header , configHeader , key ) {
var meta , cl4ss ,
val = '' ,
$header = $ ( header ) ;
if ( ! $header . length ) { return '' ; }
meta = $ . metadata ? $header . metadata ( ) : false ;
cl4ss = ' ' + ( $header . attr ( 'class' ) || '' ) ;
if ( typeof $header . data ( key ) !== 'undefined' ||
typeof $header . data ( key . toLowerCase ( ) ) !== 'undefined' ) {
// 'data-lockedOrder' is assigned to 'lockedorder'; but 'data-locked-order' is assigned to 'lockedOrder'
// 'data-sort-initial-order' is assigned to 'sortInitialOrder'
val += $header . data ( key ) || $header . data ( key . toLowerCase ( ) ) ;
} else if ( meta && typeof meta [ key ] !== 'undefined' ) {
val += meta [ key ] ;
} else if ( configHeader && typeof configHeader [ key ] !== 'undefined' ) {
val += configHeader [ key ] ;
} else if ( cl4ss !== ' ' && cl4ss . match ( ' ' + key + '-' ) ) {
// include sorter class name 'sorter-text', etc; now works with 'sorter-my-custom-parser'
val = cl4ss . match ( new RegExp ( '\\s' + key + '-([\\w-]+)' ) ) [ 1 ] || '' ;
}
return $ . trim ( val ) ;
} ,
getColumnData : function ( table , obj , indx , getCell , $headers ) {
2016-11-27 01:40:00 +00:00
if ( typeof obj !== 'object' || obj === null ) {
return obj ;
}
2015-10-18 18:21:11 +00:00
table = $ ( table ) [ 0 ] ;
var $header , key ,
c = table . config ,
$cells = ( $headers || c . $headers ) ,
// c.$headerIndexed is not defined initially
$cell = c . $headerIndexed && c . $headerIndexed [ indx ] ||
2017-12-13 21:17:20 +00:00
$cells . find ( '[data-column="' + indx + '"]:last' ) ;
2016-08-17 17:41:10 +00:00
if ( typeof obj [ indx ] !== 'undefined' ) {
2015-10-18 18:21:11 +00:00
return getCell ? obj [ indx ] : obj [ $cells . index ( $cell ) ] ;
}
for ( key in obj ) {
if ( typeof key === 'string' ) {
$header = $cell
// header cell with class/id
. filter ( key )
// find elements within the header cell with cell/id
. add ( $cell . find ( key ) ) ;
if ( $header . length ) {
return obj [ key ] ;
}
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
}
return ;
} ,
// *** Process table ***
// add processing indicator
2015-11-10 21:27:30 +00:00
isProcessing : function ( $table , toggle , $headers ) {
2015-10-18 18:21:11 +00:00
$table = $ ( $table ) ;
var c = $table [ 0 ] . config ,
// default to all headers
2015-11-10 21:27:30 +00:00
$header = $headers || $table . find ( '.' + ts . css . header ) ;
2015-10-18 18:21:11 +00:00
if ( toggle ) {
2015-11-10 21:27:30 +00:00
// don't use sortList if custom $headers used
if ( typeof $headers !== 'undefined' && c . sortList . length > 0 ) {
2015-10-18 18:21:11 +00:00
// get headers from the sortList
$header = $header . filter ( function ( ) {
// get data-column from attr to keep compatibility with jQuery 1.2.6
return this . sortDisabled ?
false :
ts . isValueInArray ( parseFloat ( $ ( this ) . attr ( 'data-column' ) ) , c . sortList ) >= 0 ;
} ) ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
$table . add ( $header ) . addClass ( ts . css . processing + ' ' + c . cssProcessing ) ;
} else {
$table . add ( $header ) . removeClass ( ts . css . processing + ' ' + c . cssProcessing ) ;
}
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
// detach tbody but save the position
// don't use tbody because there are portions that look for a tbody index (updateCell)
processTbody : function ( table , $tb , getIt ) {
table = $ ( table ) [ 0 ] ;
if ( getIt ) {
table . isProcessing = true ;
$tb . before ( '<colgroup class="tablesorter-savemyplace"/>' ) ;
return $ . fn . detach ? $tb . detach ( ) : $tb . remove ( ) ;
}
var holdr = $ ( table ) . find ( 'colgroup.tablesorter-savemyplace' ) ;
$tb . insertAfter ( holdr ) ;
holdr . remove ( ) ;
table . isProcessing = false ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
clearTableBody : function ( table ) {
$ ( table ) [ 0 ] . config . $tbodies . children ( ) . detach ( ) ;
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
// used when replacing accented characters during sorting
characterEquivalents : {
'a' : '\u00e1\u00e0\u00e2\u00e3\u00e4\u0105\u00e5' , // áàâãäąå
'A' : '\u00c1\u00c0\u00c2\u00c3\u00c4\u0104\u00c5' , // ÁÀÂÃÄĄÅ
'c' : '\u00e7\u0107\u010d' , // çćč
'C' : '\u00c7\u0106\u010c' , // ÇĆČ
'e' : '\u00e9\u00e8\u00ea\u00eb\u011b\u0119' , // éèêëěę
'E' : '\u00c9\u00c8\u00ca\u00cb\u011a\u0118' , // ÉÈÊËĚĘ
'i' : '\u00ed\u00ec\u0130\u00ee\u00ef\u0131' , // íìİîïı
'I' : '\u00cd\u00cc\u0130\u00ce\u00cf' , // ÍÌİÎÏ
'o' : '\u00f3\u00f2\u00f4\u00f5\u00f6\u014d' , // óòôõöō
'O' : '\u00d3\u00d2\u00d4\u00d5\u00d6\u014c' , // ÓÒÔÕÖŌ
'ss' : '\u00df' , // ß (s sharp)
'SS' : '\u1e9e' , // ẞ (Capital sharp s)
'u' : '\u00fa\u00f9\u00fb\u00fc\u016f' , // úùûüů
'U' : '\u00da\u00d9\u00db\u00dc\u016e' // ÚÙÛÜŮ
} ,
2015-03-28 20:03:50 +00:00
2015-10-18 18:21:11 +00:00
replaceAccents : function ( str ) {
var chr ,
acc = '[' ,
eq = ts . characterEquivalents ;
if ( ! ts . characterRegex ) {
ts . characterRegexArray = { } ;
for ( chr in eq ) {
if ( typeof chr === 'string' ) {
acc += eq [ chr ] ;
ts . characterRegexArray [ chr ] = new RegExp ( '[' + eq [ chr ] + ']' , 'g' ) ;
}
}
ts . characterRegex = new RegExp ( acc + ']' ) ;
}
if ( ts . characterRegex . test ( str ) ) {
for ( chr in eq ) {
if ( typeof chr === 'string' ) {
str = str . replace ( ts . characterRegexArray [ chr ] , chr ) ;
}
}
}
return str ;
} ,
2016-11-27 01:40:00 +00:00
validateOptions : function ( c ) {
var setting , setting2 , typ , timer ,
// ignore options containing an array
2016-12-08 13:48:07 +00:00
ignore = 'headers sortForce sortList sortAppend widgets' . split ( ' ' ) ,
2016-11-27 01:40:00 +00:00
orig = c . originalSettings ;
if ( orig ) {
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2016-11-27 01:40:00 +00:00
timer = new Date ( ) ;
}
for ( setting in orig ) {
typ = typeof ts . defaults [ setting ] ;
if ( typ === 'undefined' ) {
console . warn ( 'Tablesorter Warning! "table.config.' + setting + '" option not recognized' ) ;
} else if ( typ === 'object' ) {
for ( setting2 in orig [ setting ] ) {
2016-12-08 13:48:07 +00:00
typ = ts . defaults [ setting ] && typeof ts . defaults [ setting ] [ setting2 ] ;
2016-11-27 01:40:00 +00:00
if ( $ . inArray ( setting , ignore ) < 0 && typ === 'undefined' ) {
console . warn ( 'Tablesorter Warning! "table.config.' + setting + '.' + setting2 + '" option not recognized' ) ;
}
}
}
}
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2016-11-27 01:40:00 +00:00
console . log ( 'validate options time:' + ts . benchmark ( timer ) ) ;
}
}
} ,
2015-10-18 18:21:11 +00:00
// restore headers
restoreHeaders : function ( table ) {
var index , $cell ,
c = $ ( table ) [ 0 ] . config ,
$headers = c . $table . find ( c . selectorHeaders ) ,
len = $headers . length ;
// don't use c.$headers here in case header cells were swapped
for ( index = 0 ; index < len ; index ++ ) {
$cell = $headers . eq ( index ) ;
// only restore header cells if it is wrapped
// because this is also used by the updateAll method
if ( $cell . find ( '.' + ts . css . headerIn ) . length ) {
$cell . html ( c . headerContent [ index ] ) ;
}
}
} ,
destroy : function ( table , removeClasses , callback ) {
table = $ ( table ) [ 0 ] ;
if ( ! table . hasInitialized ) { return ; }
// remove all widgets
ts . removeWidget ( table , true , false ) ;
var events ,
$t = $ ( table ) ,
c = table . config ,
$h = $t . find ( 'thead:first' ) ,
$r = $h . find ( 'tr.' + ts . css . headerRow ) . removeClass ( ts . css . headerRow + ' ' + c . cssHeaderRow ) ,
$f = $t . find ( 'tfoot:first > tr' ) . children ( 'th, td' ) ;
if ( removeClasses === false && $ . inArray ( 'uitheme' , c . widgets ) >= 0 ) {
// reapply uitheme classes, in case we want to maintain appearance
2015-12-02 01:38:56 +00:00
$t . triggerHandler ( 'applyWidgetId' , [ 'uitheme' ] ) ;
$t . triggerHandler ( 'applyWidgetId' , [ 'zebra' ] ) ;
2015-10-18 18:21:11 +00:00
}
// remove widget added rows, just in case
$h . find ( 'tr' ) . not ( $r ) . remove ( ) ;
2015-12-13 22:24:42 +00:00
// disable tablesorter - not using .unbind( namespace ) because namespacing was
// added in jQuery v1.4.3 - see http://api.jquery.com/event.namespace/
2015-10-18 18:21:11 +00:00
events = 'sortReset update updateRows updateAll updateHeaders updateCell addRows updateComplete sorton ' +
2015-12-13 22:24:42 +00:00
'appendCache updateCache applyWidgetId applyWidgets refreshWidgets removeWidget destroy mouseup mouseleave ' +
'keypress sortBegin sortEnd resetToLoadState ' . split ( ' ' )
2015-10-18 18:21:11 +00:00
. join ( c . namespace + ' ' ) ;
$t
. removeData ( 'tablesorter' )
. unbind ( events . replace ( ts . regex . spaces , ' ' ) ) ;
c . $headers
. add ( $f )
. removeClass ( [ ts . css . header , c . cssHeader , c . cssAsc , c . cssDesc , ts . css . sortAsc , ts . css . sortDesc , ts . css . sortNone ] . join ( ' ' ) )
. removeAttr ( 'data-column' )
. removeAttr ( 'aria-label' )
. attr ( 'aria-disabled' , 'true' ) ;
$r
. find ( c . selectorSort )
. unbind ( ( 'mousedown mouseup keypress ' . split ( ' ' ) . join ( c . namespace + ' ' ) ) . replace ( ts . regex . spaces , ' ' ) ) ;
ts . restoreHeaders ( table ) ;
$t . toggleClass ( ts . css . table + ' ' + c . tableClass + ' tablesorter-' + c . theme , removeClasses === false ) ;
2017-05-16 20:33:15 +00:00
$t . removeClass ( c . namespace . slice ( 1 ) ) ;
2015-10-18 18:21:11 +00:00
// clear flag in case the plugin is initialized again
table . hasInitialized = false ;
delete table . config . cache ;
if ( typeof callback === 'function' ) {
callback ( table ) ;
}
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'core' ) ) {
2015-10-18 18:21:11 +00:00
console . log ( 'tablesorter has been removed' ) ;
}
}
} ;
$ . fn . tablesorter = function ( settings ) {
return this . each ( function ( ) {
var table = this ,
// merge & extend config options
c = $ . extend ( true , { } , ts . defaults , settings , ts . instanceMethods ) ;
// save initial settings
c . originalSettings = settings ;
// create a table from data (build table widget)
if ( ! table . hasInitialized && ts . buildTable && this . nodeName !== 'TABLE' ) {
// return the table (in case the original target is the table's container)
ts . buildTable ( table , c ) ;
} else {
ts . setup ( table , c ) ;
}
} ) ;
} ;
2015-03-28 20:03:50 +00:00
2015-07-24 23:23:00 +00:00
// set up debug logs
2015-09-22 05:17:35 +00:00
if ( ! ( window . console && window . console . log ) ) {
2015-10-18 18:21:11 +00:00
// access $.tablesorter.logs for browsers that don't have a console...
2015-07-24 23:23:00 +00:00
ts . logs = [ ] ;
/*jshint -W020 */
console = { } ;
console . log = console . warn = console . error = console . table = function ( ) {
2015-10-18 18:21:11 +00:00
var arg = arguments . length > 1 ? arguments : arguments [ 0 ] ;
2016-03-02 05:00:22 +00:00
ts . logs [ ts . logs . length ] = { date : Date . now ( ) , log : arg } ;
2015-07-24 23:23:00 +00:00
} ;
}
2015-03-28 20:03:50 +00:00
// add default parsers
ts . addParser ( {
2015-10-18 18:21:11 +00:00
id : 'no-parser' ,
is : function ( ) {
2015-03-28 20:03:50 +00:00
return false ;
} ,
2015-10-18 18:21:11 +00:00
format : function ( ) {
2015-03-28 20:03:50 +00:00
return '' ;
} ,
2015-10-18 18:21:11 +00:00
type : 'text'
2015-03-28 20:03:50 +00:00
} ) ;
ts . addParser ( {
2015-10-18 18:21:11 +00:00
id : 'text' ,
is : function ( ) {
2015-03-28 20:03:50 +00:00
return true ;
} ,
2015-10-18 18:21:11 +00:00
format : function ( str , table ) {
2015-03-28 20:03:50 +00:00
var c = table . config ;
2015-10-18 18:21:11 +00:00
if ( str ) {
str = $ . trim ( c . ignoreCase ? str . toLocaleLowerCase ( ) : str ) ;
str = c . sortLocaleCompare ? ts . replaceAccents ( str ) : str ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
return str ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
type : 'text'
2015-03-28 20:03:50 +00:00
} ) ;
2015-08-23 18:22:56 +00:00
ts . regex . nondigit = /[^\w,. \-()]/g ;
2015-03-28 20:03:50 +00:00
ts . addParser ( {
2015-10-18 18:21:11 +00:00
id : 'digit' ,
is : function ( str ) {
return ts . isDigit ( str ) ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
format : function ( str , table ) {
var num = ts . formatFloat ( ( str || '' ) . replace ( ts . regex . nondigit , '' ) , table ) ;
return str && typeof num === 'number' ? num :
str ? $ . trim ( str && table . config . ignoreCase ? str . toLocaleLowerCase ( ) : str ) : str ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
type : 'numeric'
2015-03-28 20:03:50 +00:00
} ) ;
2015-08-23 18:22:56 +00:00
ts . regex . currencyReplace = /[+\-,. ]/g ;
ts . regex . currencyTest = /^\(?\d+[\u00a3$\u20ac\u00a4\u00a5\u00a2?.]|[\u00a3$\u20ac\u00a4\u00a5\u00a2?.]\d+\)?$/ ;
2015-03-28 20:03:50 +00:00
ts . addParser ( {
2015-10-18 18:21:11 +00:00
id : 'currency' ,
is : function ( str ) {
str = ( str || '' ) . replace ( ts . regex . currencyReplace , '' ) ;
2015-07-29 23:38:55 +00:00
// test for £$€¤¥¢
2015-10-18 18:21:11 +00:00
return ts . regex . currencyTest . test ( str ) ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
format : function ( str , table ) {
var num = ts . formatFloat ( ( str || '' ) . replace ( ts . regex . nondigit , '' ) , table ) ;
return str && typeof num === 'number' ? num :
str ? $ . trim ( str && table . config . ignoreCase ? str . toLocaleLowerCase ( ) : str ) : str ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
type : 'numeric'
2015-03-28 20:03:50 +00:00
} ) ;
2015-08-23 18:22:56 +00:00
// too many protocols to add them all https://en.wikipedia.org/wiki/URI_scheme
// now, this regex can be updated before initialization
2016-08-01 01:48:27 +00:00
ts . regex . urlProtocolTest = /^(https?|ftp|file):\/\// ;
ts . regex . urlProtocolReplace = /(https?|ftp|file):\/\/(www\.)?/ ;
2015-03-28 20:03:50 +00:00
ts . addParser ( {
2015-10-18 18:21:11 +00:00
id : 'url' ,
is : function ( str ) {
return ts . regex . urlProtocolTest . test ( str ) ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
format : function ( str ) {
return str ? $ . trim ( str . replace ( ts . regex . urlProtocolReplace , '' ) ) : str ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
type : 'text'
2015-03-28 20:03:50 +00:00
} ) ;
2015-08-23 18:22:56 +00:00
ts . regex . dash = /-/g ;
ts . regex . isoDate = /^\d{4}[\/\-]\d{1,2}[\/\-]\d{1,2}/ ;
2015-03-28 20:03:50 +00:00
ts . addParser ( {
2015-10-18 18:21:11 +00:00
id : 'isoDate' ,
is : function ( str ) {
return ts . regex . isoDate . test ( str ) ;
2015-03-28 20:03:50 +00:00
} ,
2018-03-18 13:49:07 +00:00
format : function ( str ) {
2015-10-18 18:21:11 +00:00
var date = str ? new Date ( str . replace ( ts . regex . dash , '/' ) ) : str ;
return date instanceof Date && isFinite ( date ) ? date . getTime ( ) : str ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
type : 'numeric'
2015-03-28 20:03:50 +00:00
} ) ;
2015-08-23 18:22:56 +00:00
ts . regex . percent = /%/g ;
ts . regex . percentTest = /(\d\s*?%|%\s*?\d)/ ;
2015-03-28 20:03:50 +00:00
ts . addParser ( {
2015-10-18 18:21:11 +00:00
id : 'percent' ,
is : function ( str ) {
return ts . regex . percentTest . test ( str ) && str . length < 15 ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
format : function ( str , table ) {
return str ? ts . formatFloat ( str . replace ( ts . regex . percent , '' ) , table ) : str ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
type : 'numeric'
2015-03-28 20:03:50 +00:00
} ) ;
// added image parser to core v2.17.9
ts . addParser ( {
2015-10-18 18:21:11 +00:00
id : 'image' ,
is : function ( str , table , node , $node ) {
return $node . find ( 'img' ) . length > 0 ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
format : function ( str , table , cell ) {
return $ ( cell ) . find ( 'img' ) . attr ( table . config . imgAttr || 'alt' ) || str ;
2015-03-28 20:03:50 +00:00
} ,
parsed : true , // filter widget flag
2015-10-18 18:21:11 +00:00
type : 'text'
2015-03-28 20:03:50 +00:00
} ) ;
2015-08-23 18:22:56 +00:00
ts . regex . dateReplace = /(\S)([AP]M)$/i ; // used by usLongDate & time parser
ts . regex . usLongDateTest1 = /^[A-Z]{3,10}\.?\s+\d{1,2},?\s+(\d{4})(\s+\d{1,2}:\d{2}(:\d{2})?(\s+[AP]M)?)?$/i ;
ts . regex . usLongDateTest2 = /^\d{1,2}\s+[A-Z]{3,10}\s+\d{4}/i ;
2015-03-28 20:03:50 +00:00
ts . addParser ( {
2015-10-18 18:21:11 +00:00
id : 'usLongDate' ,
is : function ( str ) {
2015-03-28 20:03:50 +00:00
// two digit years are not allowed cross-browser
// Jan 01, 2013 12:34:56 PM or 01 Jan 2013
2015-10-18 18:21:11 +00:00
return ts . regex . usLongDateTest1 . test ( str ) || ts . regex . usLongDateTest2 . test ( str ) ;
2015-03-28 20:03:50 +00:00
} ,
2018-03-18 13:49:07 +00:00
format : function ( str ) {
2015-10-18 18:21:11 +00:00
var date = str ? new Date ( str . replace ( ts . regex . dateReplace , '$1 $2' ) ) : str ;
return date instanceof Date && isFinite ( date ) ? date . getTime ( ) : str ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
type : 'numeric'
2015-03-28 20:03:50 +00:00
} ) ;
2015-08-23 18:22:56 +00:00
// testing for ##-##-#### or ####-##-##, so it's not perfect; time can be included
ts . regex . shortDateTest = /(^\d{1,2}[\/\s]\d{1,2}[\/\s]\d{4})|(^\d{4}[\/\s]\d{1,2}[\/\s]\d{1,2})/ ;
// escaped "-" because JSHint in Firefox was showing it as an error
ts . regex . shortDateReplace = /[\-.,]/g ;
// XXY covers MDY & DMY formats
ts . regex . shortDateXXY = /(\d{1,2})[\/\s](\d{1,2})[\/\s](\d{4})/ ;
ts . regex . shortDateYMD = /(\d{4})[\/\s](\d{1,2})[\/\s](\d{1,2})/ ;
2015-11-02 16:50:31 +00:00
ts . convertFormat = function ( dateString , format ) {
dateString = ( dateString || '' )
. replace ( ts . regex . spaces , ' ' )
. replace ( ts . regex . shortDateReplace , '/' ) ;
if ( format === 'mmddyyyy' ) {
dateString = dateString . replace ( ts . regex . shortDateXXY , '$3/$1/$2' ) ;
} else if ( format === 'ddmmyyyy' ) {
dateString = dateString . replace ( ts . regex . shortDateXXY , '$3/$2/$1' ) ;
} else if ( format === 'yyyymmdd' ) {
dateString = dateString . replace ( ts . regex . shortDateYMD , '$1/$2/$3' ) ;
}
var date = new Date ( dateString ) ;
return date instanceof Date && isFinite ( date ) ? date . getTime ( ) : '' ;
} ;
2015-03-28 20:03:50 +00:00
ts . addParser ( {
2015-10-18 18:21:11 +00:00
id : 'shortDate' , // 'mmddyyyy', 'ddmmyyyy' or 'yyyymmdd'
is : function ( str ) {
str = ( str || '' ) . replace ( ts . regex . spaces , ' ' ) . replace ( ts . regex . shortDateReplace , '/' ) ;
return ts . regex . shortDateTest . test ( str ) ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
format : function ( str , table , cell , cellIndex ) {
if ( str ) {
2015-11-02 16:50:31 +00:00
var c = table . config ,
$header = c . $headerIndexed [ cellIndex ] ,
format = $header . length && $header . data ( 'dateFormat' ) ||
ts . getData ( $header , ts . getColumnData ( table , c . headers , cellIndex ) , 'dateFormat' ) ||
2015-07-29 23:38:55 +00:00
c . dateFormat ;
2015-11-02 16:50:31 +00:00
// save format because getData can be slow...
if ( $header . length ) {
$header . data ( 'dateFormat' , format ) ;
2015-10-18 18:21:11 +00:00
}
2015-11-02 16:50:31 +00:00
return ts . convertFormat ( str , format ) || str ;
2015-03-28 20:03:50 +00:00
}
2015-10-18 18:21:11 +00:00
return str ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
type : 'numeric'
2015-03-28 20:03:50 +00:00
} ) ;
2015-11-02 16:50:31 +00:00
// match 24 hour time & 12 hours time + am/pm - see http://regexr.com/3c3tk
2016-08-02 19:56:10 +00:00
ts . regex . timeTest = /^(0?[1-9]|1[0-2]):([0-5]\d)(\s[AP]M)$|^((?:[01]\d|[2][0-4]):[0-5]\d)$/i ;
ts . regex . timeMatch = /(0?[1-9]|1[0-2]):([0-5]\d)(\s[AP]M)|((?:[01]\d|[2][0-4]):[0-5]\d)/i ;
2015-03-28 20:03:50 +00:00
ts . addParser ( {
2015-10-18 18:21:11 +00:00
id : 'time' ,
is : function ( str ) {
return ts . regex . timeTest . test ( str ) ;
2015-03-28 20:03:50 +00:00
} ,
2018-03-18 13:49:07 +00:00
format : function ( str ) {
2015-11-02 16:50:31 +00:00
// isolate time... ignore month, day and year
var temp ,
timePart = ( str || '' ) . match ( ts . regex . timeMatch ) ,
orig = new Date ( str ) ,
// no time component? default to 00:00 by leaving it out, but only if str is defined
time = str && ( timePart !== null ? timePart [ 0 ] : '00:00 AM' ) ,
date = time ? new Date ( '2000/01/01 ' + time . replace ( ts . regex . dateReplace , '$1 $2' ) ) : time ;
if ( date instanceof Date && isFinite ( date ) ) {
temp = orig instanceof Date && isFinite ( orig ) ? orig . getTime ( ) : 0 ;
// if original string was a valid date, add it to the decimal so the column sorts in some kind of order
// luckily new Date() ignores the decimals
return temp ? parseFloat ( date . getTime ( ) + '.' + orig . getTime ( ) ) : date . getTime ( ) ;
}
return str ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
type : 'numeric'
2015-03-28 20:03:50 +00:00
} ) ;
ts . addParser ( {
2015-10-18 18:21:11 +00:00
id : 'metadata' ,
is : function ( ) {
2015-03-28 20:03:50 +00:00
return false ;
} ,
2015-10-18 18:21:11 +00:00
format : function ( str , table , cell ) {
2015-03-28 20:03:50 +00:00
var c = table . config ,
2015-10-18 18:21:11 +00:00
p = ( ! c . parserMetadataName ) ? 'sortValue' : c . parserMetadataName ;
return $ ( cell ) . metadata ( ) [ p ] ;
2015-03-28 20:03:50 +00:00
} ,
2015-10-18 18:21:11 +00:00
type : 'numeric'
2015-03-28 20:03:50 +00:00
} ) ;
2015-10-18 18:21:11 +00:00
/ *
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ ▄ █ █ █ █ █ ▄ ▄ █ █ █ █ ▄
▄ █ ▀ █ █ ▄ ▄ █ █ ▄ ▄ █ █ █ █ ▄ ▄ █ █ █ █ ▄ ▄ █ █
▄ █ ▀ █ █ ▀ ▀ █ █ ▀ ▀ █ █ █ █ ▀ ▀ █ █ █ ▀ ▀ █ █
█ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ █ ▀ █ █ █ █ █ █ █ █
* /
2015-03-28 20:03:50 +00:00
// add default widgets
ts . addWidget ( {
2015-10-18 18:21:11 +00:00
id : 'zebra' ,
priority : 90 ,
format : function ( table , c , wo ) {
var $visibleRows , $row , count , isEven , tbodyIndex , rowIndex , len ,
child = new RegExp ( c . cssChildRow , 'i' ) ,
$tbodies = c . $tbodies . add ( $ ( c . namespace + '_extra_table' ) . children ( 'tbody:not(.' + c . cssInfoBlock + ')' ) ) ;
for ( tbodyIndex = 0 ; tbodyIndex < $tbodies . length ; tbodyIndex ++ ) {
2015-03-28 20:03:50 +00:00
// loop through the visible rows
2015-10-18 18:21:11 +00:00
count = 0 ;
$visibleRows = $tbodies . eq ( tbodyIndex ) . children ( 'tr:visible' ) . not ( c . selectorRemove ) ;
len = $visibleRows . length ;
for ( rowIndex = 0 ; rowIndex < len ; rowIndex ++ ) {
$row = $visibleRows . eq ( rowIndex ) ;
2015-03-28 20:03:50 +00:00
// style child rows the same way the parent row was styled
2015-10-18 18:21:11 +00:00
if ( ! child . test ( $row [ 0 ] . className ) ) { count ++ ; }
isEven = ( count % 2 === 0 ) ;
$row
. removeClass ( wo . zebra [ isEven ? 1 : 0 ] )
. addClass ( wo . zebra [ isEven ? 0 : 1 ] ) ;
2015-05-17 20:32:53 +00:00
}
2015-03-28 20:03:50 +00:00
}
} ,
2015-10-18 18:21:11 +00:00
remove : function ( table , c , wo , refreshing ) {
if ( refreshing ) { return ; }
var tbodyIndex , $tbody ,
$tbodies = c . $tbodies ,
toRemove = ( wo . zebra || [ 'even' , 'odd' ] ) . join ( ' ' ) ;
2018-03-18 13:49:07 +00:00
for ( tbodyIndex = 0 ; tbodyIndex < $tbodies . length ; tbodyIndex ++ ) {
2015-10-18 18:21:11 +00:00
$tbody = ts . processTbody ( table , $tbodies . eq ( tbodyIndex ) , true ) ; // remove tbody
$tbody . children ( ) . removeClass ( toRemove ) ;
ts . processTbody ( table , $tbody , false ) ; // restore tbody
2015-03-28 20:03:50 +00:00
}
}
} ) ;
2015-10-18 18:21:11 +00:00
} ) ( jQuery ) ;
2015-03-28 20:03:50 +00:00
2018-03-18 13:49:07 +00:00
/*! Widget: storage - updated 2018-03-18 (v2.30.0) */
2015-07-28 20:57:01 +00:00
/*global JSON:false */
2015-03-28 20:03:50 +00:00
; ( function ( $ , window , document ) {
2015-07-23 04:29:51 +00:00
'use strict' ;
var ts = $ . tablesorter || { } ;
2017-04-19 00:50:08 +00:00
// update defaults for validator; these values must be falsy!
$ . extend ( true , ts . defaults , {
fixedUrl : '' ,
widgetOptions : {
storage _fixedUrl : '' ,
storage _group : '' ,
storage _page : '' ,
storage _storageType : '' ,
storage _tableId : '' ,
storage _useSessionStorage : ''
}
} ) ;
2015-07-23 04:29:51 +00:00
// *** Store data in local storage, with a cookie fallback ***
/* IE7 needs JSON library for JSON.stringify - (http:/ / caniuse . com / # search = json )
if you need it , then include https : //github.com/douglascrockford/JSON-js
$ . parseJSON is not available is jQuery versions older than 1.4 . 1 , using older
versions will only allow storing information for one page at a time
// *** Save data (JSON format only) ***
// val must be valid JSON... use http://jsonlint.com/ to ensure it is valid
var val = { "mywidget" : "data1" } ; // valid JSON uses double quotes
// $.tablesorter.storage(table, key, val);
$ . tablesorter . storage ( table , 'tablesorter-mywidget' , val ) ;
// *** Get data: $.tablesorter.storage(table, key); ***
v = $ . tablesorter . storage ( table , 'tablesorter-mywidget' ) ;
// val may be empty, so also check for your data
val = ( v && v . hasOwnProperty ( 'mywidget' ) ) ? v . mywidget : '' ;
alert ( val ) ; // 'data1' if saved, or '' if not
* /
ts . storage = function ( table , key , value , options ) {
table = $ ( table ) [ 0 ] ;
var cookieIndex , cookies , date ,
hasStorage = false ,
values = { } ,
c = table . config ,
wo = c && c . widgetOptions ,
2018-03-18 13:49:07 +00:00
debug = ts . debug ( c , 'storage' ) ,
2017-04-19 00:50:08 +00:00
storageType = (
( options && options . storageType ) || ( wo && wo . storage _storageType )
) . toString ( ) . charAt ( 0 ) . toLowerCase ( ) ,
// deprecating "useSessionStorage"; any storageType setting overrides it
session = storageType ? '' :
( options && options . useSessionStorage ) || ( wo && wo . storage _useSessionStorage ) ,
2015-07-23 04:29:51 +00:00
$table = $ ( table ) ,
// id from (1) options ID, (2) table 'data-table-group' attribute, (3) widgetOptions.storage_tableId,
// (4) table ID, then (5) table index
id = options && options . id ||
$table . attr ( options && options . group || wo && wo . storage _group || 'data-table-group' ) ||
wo && wo . storage _tableId || table . id || $ ( '.tablesorter' ) . index ( $table ) ,
// url from (1) options url, (2) table 'data-table-page' attribute, (3) widgetOptions.storage_fixedUrl,
// (4) table.config.fixedUrl (deprecated), then (5) window location path
url = options && options . url ||
$table . attr ( options && options . page || wo && wo . storage _page || 'data-table-page' ) ||
wo && wo . storage _fixedUrl || c && c . fixedUrl || window . location . pathname ;
2017-04-19 00:50:08 +00:00
// skip if using cookies
if ( storageType !== 'c' ) {
storageType = ( storageType === 's' || session ) ? 'sessionStorage' : 'localStorage' ;
// https://gist.github.com/paulirish/5558557
if ( storageType in window ) {
try {
window [ storageType ] . setItem ( '_tmptest' , 'temp' ) ;
hasStorage = true ;
window [ storageType ] . removeItem ( '_tmptest' ) ;
} catch ( error ) {
2018-03-18 13:49:07 +00:00
console . warn ( storageType + ' is not supported in this browser' ) ;
2015-07-23 04:29:51 +00:00
}
2015-03-28 20:03:50 +00:00
}
}
2018-03-18 13:49:07 +00:00
if ( debug ) {
console . log ( 'Storage >> Using' , hasStorage ? storageType : 'cookies' ) ;
2017-04-19 00:50:08 +00:00
}
2015-07-23 04:29:51 +00:00
// *** get value ***
if ( $ . parseJSON ) {
if ( hasStorage ) {
values = $ . parseJSON ( window [ storageType ] [ key ] || 'null' ) || { } ;
} else {
// old browser, using cookies
cookies = document . cookie . split ( /[;\s|=]/ ) ;
// add one to get from the key to the value
cookieIndex = $ . inArray ( key , cookies ) + 1 ;
values = ( cookieIndex !== 0 ) ? $ . parseJSON ( cookies [ cookieIndex ] || 'null' ) || { } : { } ;
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
// allow value to be an empty string too
2016-03-02 05:00:22 +00:00
if ( typeof value !== 'undefined' && window . JSON && JSON . hasOwnProperty ( 'stringify' ) ) {
2015-07-23 04:29:51 +00:00
// add unique identifiers = url pathname > table ID/index on page > data
if ( ! values [ url ] ) {
values [ url ] = { } ;
}
values [ url ] [ id ] = value ;
// *** set value ***
if ( hasStorage ) {
window [ storageType ] [ key ] = JSON . stringify ( values ) ;
} else {
date = new Date ( ) ;
date . setTime ( date . getTime ( ) + ( 31536e+6 ) ) ; // 365 days
document . cookie = key + '=' + ( JSON . stringify ( values ) ) . replace ( /\"/g , '\"' ) + '; expires=' + date . toGMTString ( ) + '; path=/' ;
}
2015-03-28 20:03:50 +00:00
} else {
2015-07-23 04:29:51 +00:00
return values && values [ url ] ? values [ url ] [ id ] : '' ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ;
2015-03-28 20:03:50 +00:00
} ) ( jQuery , window , document ) ;
2018-03-18 13:49:07 +00:00
/*! Widget: uitheme - updated 2018-03-18 (v2.30.0) */
2015-03-28 20:03:50 +00:00
; ( function ( $ ) {
2015-07-23 04:29:51 +00:00
'use strict' ;
var ts = $ . tablesorter || { } ;
ts . themes = {
'bootstrap' : {
table : 'table table-bordered table-striped' ,
caption : 'caption' ,
// header class names
header : 'bootstrap-header' , // give the header a gradient background (theme.bootstrap_2.css)
sortNone : '' ,
sortAsc : '' ,
sortDesc : '' ,
active : '' , // applied when column is sorted
hover : '' , // custom css required - a defined bootstrap style may not override other classes
// icon class names
2017-07-19 19:20:01 +00:00
icons : '' , // add 'bootstrap-icon-white' to make them white; this icon class is added to the <i> in the header
2015-07-23 04:29:51 +00:00
iconSortNone : 'bootstrap-icon-unsorted' , // class name added to icon when column is not sorted
2017-07-19 19:20:01 +00:00
iconSortAsc : 'glyphicon glyphicon-chevron-up' , // class name added to icon when column has ascending sort
iconSortDesc : 'glyphicon glyphicon-chevron-down' , // class name added to icon when column has descending sort
2015-07-23 04:29:51 +00:00
filterRow : '' , // filter row class
footerRow : '' ,
footerCells : '' ,
even : '' , // even row zebra striping
odd : '' // odd row zebra striping
} ,
'jui' : {
table : 'ui-widget ui-widget-content ui-corner-all' , // table classes
caption : 'ui-widget-content' ,
// header class names
header : 'ui-widget-header ui-corner-all ui-state-default' , // header classes
sortNone : '' ,
sortAsc : '' ,
sortDesc : '' ,
active : 'ui-state-active' , // applied when column is sorted
hover : 'ui-state-hover' , // hover class
// icon class names
icons : 'ui-icon' , // icon class added to the <i> in the header
2016-08-01 01:48:27 +00:00
iconSortNone : 'ui-icon-carat-2-n-s ui-icon-caret-2-n-s' , // class name added to icon when column is not sorted
iconSortAsc : 'ui-icon-carat-1-n ui-icon-caret-1-n' , // class name added to icon when column has ascending sort
iconSortDesc : 'ui-icon-carat-1-s ui-icon-caret-1-s' , // class name added to icon when column has descending sort
2015-07-23 04:29:51 +00:00
filterRow : '' ,
footerRow : '' ,
footerCells : '' ,
even : 'ui-widget-content' , // even row zebra striping
odd : 'ui-state-default' // odd row zebra striping
}
} ;
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
$ . extend ( ts . css , {
wrapper : 'tablesorter-wrapper' // ui theme & resizable
} ) ;
ts . addWidget ( {
id : 'uitheme' ,
priority : 10 ,
format : function ( table , c , wo ) {
2016-07-11 12:42:19 +00:00
var i , tmp , hdr , icon , time , $header , $icon , $tfoot , $h , oldtheme , oldremove , oldIconRmv , hasOldTheme ,
2015-07-23 04:29:51 +00:00
themesAll = ts . themes ,
$table = c . $table . add ( $ ( c . namespace + '_extra_table' ) ) ,
$headers = c . $headers . add ( $ ( c . namespace + '_extra_headers' ) ) ,
theme = c . theme || 'jui' ,
themes = themesAll [ theme ] || { } ,
remove = $ . trim ( [ themes . sortNone , themes . sortDesc , themes . sortAsc , themes . active ] . join ( ' ' ) ) ,
2018-03-18 13:49:07 +00:00
iconRmv = $ . trim ( [ themes . iconSortNone , themes . iconSortDesc , themes . iconSortAsc ] . join ( ' ' ) ) ,
debug = ts . debug ( c , 'uitheme' ) ;
if ( debug ) { time = new Date ( ) ; }
2015-07-23 04:29:51 +00:00
// initialization code - run once
if ( ! $table . hasClass ( 'tablesorter-' + theme ) || c . theme !== c . appliedTheme || ! wo . uitheme _applied ) {
wo . uitheme _applied = true ;
oldtheme = themesAll [ c . appliedTheme ] || { } ;
hasOldTheme = ! $ . isEmptyObject ( oldtheme ) ;
oldremove = hasOldTheme ? [ oldtheme . sortNone , oldtheme . sortDesc , oldtheme . sortAsc , oldtheme . active ] . join ( ' ' ) : '' ;
oldIconRmv = hasOldTheme ? [ oldtheme . iconSortNone , oldtheme . iconSortDesc , oldtheme . iconSortAsc ] . join ( ' ' ) : '' ;
if ( hasOldTheme ) {
wo . zebra [ 0 ] = $ . trim ( ' ' + wo . zebra [ 0 ] . replace ( ' ' + oldtheme . even , '' ) ) ;
wo . zebra [ 1 ] = $ . trim ( ' ' + wo . zebra [ 1 ] . replace ( ' ' + oldtheme . odd , '' ) ) ;
c . $tbodies . children ( ) . removeClass ( [ oldtheme . even , oldtheme . odd ] . join ( ' ' ) ) ;
}
// update zebra stripes
if ( themes . even ) { wo . zebra [ 0 ] += ' ' + themes . even ; }
if ( themes . odd ) { wo . zebra [ 1 ] += ' ' + themes . odd ; }
// add caption style
$table . children ( 'caption' )
. removeClass ( oldtheme . caption || '' )
. addClass ( themes . caption ) ;
// add table/footer class names
$tfoot = $table
// remove other selected themes
. removeClass ( ( c . appliedTheme ? 'tablesorter-' + ( c . appliedTheme || '' ) : '' ) + ' ' + ( oldtheme . table || '' ) )
. addClass ( 'tablesorter-' + theme + ' ' + ( themes . table || '' ) ) // add theme widget class name
. children ( 'tfoot' ) ;
c . appliedTheme = c . theme ;
if ( $tfoot . length ) {
$tfoot
// if oldtheme.footerRow or oldtheme.footerCells are undefined, all class names are removed
. children ( 'tr' ) . removeClass ( oldtheme . footerRow || '' ) . addClass ( themes . footerRow )
. children ( 'th, td' ) . removeClass ( oldtheme . footerCells || '' ) . addClass ( themes . footerCells ) ;
}
// update header classes
2015-03-28 20:03:50 +00:00
$headers
2015-07-23 04:29:51 +00:00
. removeClass ( ( hasOldTheme ? [ oldtheme . header , oldtheme . hover , oldremove ] . join ( ' ' ) : '' ) || '' )
. addClass ( themes . header )
. not ( '.sorter-false' )
. unbind ( 'mouseenter.tsuitheme mouseleave.tsuitheme' )
. bind ( 'mouseenter.tsuitheme mouseleave.tsuitheme' , function ( event ) {
// toggleClass with switch added in jQuery 1.3
$ ( this ) [ event . type === 'mouseenter' ? 'addClass' : 'removeClass' ] ( themes . hover || '' ) ;
} ) ;
2018-03-18 13:49:07 +00:00
$headers . each ( function ( ) {
2015-07-23 04:29:51 +00:00
var $this = $ ( this ) ;
if ( ! $this . find ( '.' + ts . css . wrapper ) . length ) {
// Firefox needs this inner div to position the icon & resizer correctly
$this . wrapInner ( '<div class="' + ts . css . wrapper + '" style="position:relative;height:100%;width:100%"></div>' ) ;
}
} ) ;
if ( c . cssIcon ) {
// if c.cssIcon is '', then no <i> is added to the header
$headers
. find ( '.' + ts . css . icon )
. removeClass ( hasOldTheme ? [ oldtheme . icons , oldIconRmv ] . join ( ' ' ) : '' )
. addClass ( themes . icons || '' ) ;
}
2016-07-11 12:42:19 +00:00
// filter widget initializes after uitheme
2016-12-08 13:48:07 +00:00
if ( ts . hasWidget ( c . table , 'filter' ) ) {
2016-07-11 12:42:19 +00:00
tmp = function ( ) {
$table . children ( 'thead' ) . children ( '.' + ts . css . filterRow )
. removeClass ( hasOldTheme ? oldtheme . filterRow || '' : '' )
. addClass ( themes . filterRow || '' ) ;
} ;
if ( wo . filter _initialized ) {
tmp ( ) ;
} else {
$table . one ( 'filterInit' , function ( ) {
tmp ( ) ;
} ) ;
}
2015-07-23 04:29:51 +00:00
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
for ( i = 0 ; i < c . columns ; i ++ ) {
$header = c . $headers
. add ( $ ( c . namespace + '_extra_headers' ) )
. not ( '.sorter-false' )
. filter ( '[data-column="' + i + '"]' ) ;
$icon = ( ts . css . icon ) ? $header . find ( '.' + ts . css . icon ) : $ ( ) ;
$h = $headers . not ( '.sorter-false' ) . filter ( '[data-column="' + i + '"]:last' ) ;
if ( $h . length ) {
$header . removeClass ( remove ) ;
$icon . removeClass ( iconRmv ) ;
if ( $h [ 0 ] . sortDisabled ) {
// no sort arrows for disabled columns!
$icon . removeClass ( themes . icons || '' ) ;
} else {
hdr = themes . sortNone ;
icon = themes . iconSortNone ;
if ( $h . hasClass ( ts . css . sortAsc ) ) {
hdr = [ themes . sortAsc , themes . active ] . join ( ' ' ) ;
icon = themes . iconSortAsc ;
} else if ( $h . hasClass ( ts . css . sortDesc ) ) {
hdr = [ themes . sortDesc , themes . active ] . join ( ' ' ) ;
icon = themes . iconSortDesc ;
}
$header . addClass ( hdr ) ;
$icon . addClass ( icon || '' ) ;
2015-03-28 20:03:50 +00:00
}
}
}
2018-03-18 13:49:07 +00:00
if ( debug ) {
console . log ( 'uitheme >> Applied ' + theme + ' theme' + ts . benchmark ( time ) ) ;
2015-07-23 04:29:51 +00:00
}
} ,
remove : function ( table , c , wo , refreshing ) {
if ( ! wo . uitheme _applied ) { return ; }
var $table = c . $table ,
theme = c . appliedTheme || 'jui' ,
themes = ts . themes [ theme ] || ts . themes . jui ,
$headers = $table . children ( 'thead' ) . children ( ) ,
remove = themes . sortNone + ' ' + themes . sortDesc + ' ' + themes . sortAsc ,
iconRmv = themes . iconSortNone + ' ' + themes . iconSortDesc + ' ' + themes . iconSortAsc ;
$table . removeClass ( 'tablesorter-' + theme + ' ' + themes . table ) ;
wo . uitheme _applied = false ;
if ( refreshing ) { return ; }
$table . find ( ts . css . header ) . removeClass ( themes . header ) ;
$headers
. unbind ( 'mouseenter.tsuitheme mouseleave.tsuitheme' ) // remove hover
. removeClass ( themes . hover + ' ' + remove + ' ' + themes . active )
. filter ( '.' + ts . css . filterRow )
. removeClass ( themes . filterRow ) ;
$headers . find ( '.' + ts . css . icon ) . removeClass ( themes . icons + ' ' + iconRmv ) ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ) ;
2015-03-28 20:03:50 +00:00
} ) ( jQuery ) ;
2017-05-24 23:53:44 +00:00
/*! Widget: columns - updated 5/24/2017 (v2.28.11) */
2015-03-28 20:03:50 +00:00
; ( function ( $ ) {
2015-07-23 04:29:51 +00:00
'use strict' ;
var ts = $ . tablesorter || { } ;
ts . addWidget ( {
id : 'columns' ,
2017-05-24 23:53:44 +00:00
priority : 65 ,
2015-07-23 04:29:51 +00:00
options : {
columns : [ 'primary' , 'secondary' , 'tertiary' ]
} ,
format : function ( table , c , wo ) {
var $tbody , tbodyIndex , $rows , rows , $row , $cells , remove , indx ,
2015-03-28 20:03:50 +00:00
$table = c . $table ,
$tbodies = c . $tbodies ,
sortList = c . sortList ,
len = sortList . length ,
// removed c.widgetColumns support
2015-07-23 04:29:51 +00:00
css = wo && wo . columns || [ 'primary' , 'secondary' , 'tertiary' ] ,
2015-03-28 20:03:50 +00:00
last = css . length - 1 ;
remove = css . join ( ' ' ) ;
2015-07-23 04:29:51 +00:00
// check if there is a sort (on initialization there may not be one)
for ( tbodyIndex = 0 ; tbodyIndex < $tbodies . length ; tbodyIndex ++ ) {
$tbody = ts . processTbody ( table , $tbodies . eq ( tbodyIndex ) , true ) ; // detach tbody
$rows = $tbody . children ( 'tr' ) ;
// loop through the visible rows
$rows . each ( function ( ) {
$row = $ ( this ) ;
if ( this . style . display !== 'none' ) {
// remove all columns class names
$cells = $row . children ( ) . removeClass ( remove ) ;
// add appropriate column class names
if ( sortList && sortList [ 0 ] ) {
// primary sort column class
$cells . eq ( sortList [ 0 ] [ 0 ] ) . addClass ( css [ 0 ] ) ;
if ( len > 1 ) {
for ( indx = 1 ; indx < len ; indx ++ ) {
// secondary, tertiary, etc sort column classes
$cells . eq ( sortList [ indx ] [ 0 ] ) . addClass ( css [ indx ] || css [ last ] ) ;
}
2015-03-28 20:03:50 +00:00
}
}
}
2015-07-23 04:29:51 +00:00
} ) ;
ts . processTbody ( table , $tbody , false ) ;
}
// add classes to thead and tfoot
rows = wo . columns _thead !== false ? [ 'thead tr' ] : [ ] ;
if ( wo . columns _tfoot !== false ) {
rows . push ( 'tfoot tr' ) ;
}
if ( rows . length ) {
$rows = $table . find ( rows . join ( ',' ) ) . children ( ) . removeClass ( remove ) ;
if ( len ) {
for ( indx = 0 ; indx < len ; indx ++ ) {
// add primary. secondary, tertiary, etc sort column classes
$rows . filter ( '[data-column="' + sortList [ indx ] [ 0 ] + '"]' ) . addClass ( css [ indx ] || css [ last ] ) ;
}
2015-03-28 20:03:50 +00:00
}
}
2015-07-23 04:29:51 +00:00
} ,
remove : function ( table , c , wo ) {
var tbodyIndex , $tbody ,
$tbodies = c . $tbodies ,
remove = ( wo . columns || [ 'primary' , 'secondary' , 'tertiary' ] ) . join ( ' ' ) ;
c . $headers . removeClass ( remove ) ;
c . $table . children ( 'tfoot' ) . children ( 'tr' ) . children ( 'th, td' ) . removeClass ( remove ) ;
for ( tbodyIndex = 0 ; tbodyIndex < $tbodies . length ; tbodyIndex ++ ) {
$tbody = ts . processTbody ( table , $tbodies . eq ( tbodyIndex ) , true ) ; // remove tbody
$tbody . children ( 'tr' ) . each ( function ( ) {
$ ( this ) . children ( ) . removeClass ( remove ) ;
} ) ;
ts . processTbody ( table , $tbody , false ) ; // restore tbody
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ) ;
2015-03-28 20:03:50 +00:00
} ) ( jQuery ) ;
2018-03-18 13:49:07 +00:00
/*! Widget: filter - updated 2018-03-18 (v2.30.0) */ / *
2015-03-28 20:03:50 +00:00
* Requires tablesorter v2 . 8 + and jQuery 1.7 +
* by Rob Garrison
* /
2015-05-17 20:32:53 +00:00
; ( function ( $ ) {
2015-07-23 04:29:51 +00:00
'use strict' ;
2015-11-10 21:27:30 +00:00
var tsf , tsfRegex ,
2015-08-23 18:22:56 +00:00
ts = $ . tablesorter || { } ,
2016-01-15 13:52:22 +00:00
tscss = ts . css ,
tskeyCodes = ts . keyCodes ;
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
$ . extend ( tscss , {
filterRow : 'tablesorter-filter-row' ,
filter : 'tablesorter-filter' ,
filterDisabled : 'disabled' ,
filterRowHide : 'hideme'
} ) ;
2016-01-15 13:52:22 +00:00
$ . extend ( tskeyCodes , {
backSpace : 8 ,
escape : 27 ,
space : 32 ,
left : 37 ,
down : 40
} ) ;
2015-07-23 04:29:51 +00:00
ts . addWidget ( {
id : 'filter' ,
priority : 50 ,
options : {
2016-05-17 00:09:45 +00:00
filter _cellFilter : '' , // css class name added to the filter cell ( string or array )
2015-07-23 04:29:51 +00:00
filter _childRows : false , // if true, filter includes child row content in the search
filter _childByColumn : false , // ( filter_childRows must be true ) if true = search child rows by column; false = search all child row text grouped
2015-09-23 12:20:32 +00:00
filter _childWithSibs : true , // if true, include matching child row siblings
2015-07-23 04:29:51 +00:00
filter _columnAnyMatch : true , // if true, allows using '#:{query}' in AnyMatch searches ( column:query )
2016-05-17 00:09:45 +00:00
filter _columnFilters : true , // if true, a filter will be added to the top of each table column
2015-07-23 04:29:51 +00:00
filter _cssFilter : '' , // css class name added to the filter row & each input in the row ( tablesorter-filter is ALWAYS added )
2016-05-17 00:09:45 +00:00
filter _defaultAttrib : 'data-value' , // data attribute in the header cell that contains the default filter value
2015-07-23 04:29:51 +00:00
filter _defaultFilter : { } , // add a default column filter type '~{query}' to make fuzzy searches default; '{q1} AND {q2}' to make all searches use a logical AND.
filter _excludeFilter : { } , // filters to exclude, per column
filter _external : '' , // jQuery selector string ( or jQuery object ) of external filters
2016-03-18 15:38:01 +00:00
filter _filteredRow : 'filtered' , // class added to filtered rows; define in css with "display:none" to hide the filtered-out rows
2018-01-18 23:30:03 +00:00
filter _filterLabel : 'Filter "{{label}}" column by...' , // Aria-label added to filter input/select; see #1495
2015-07-23 04:29:51 +00:00
filter _formatter : null , // add custom filter elements to the filter row
filter _functions : null , // add custom filter functions using this option
filter _hideEmpty : true , // hide filter row when table is empty
filter _hideFilters : false , // collapse filter row when mouse leaves the area
filter _ignoreCase : true , // if true, make all searches case-insensitive
filter _liveSearch : true , // if true, search column content while the user types ( with a delay )
2016-03-02 05:00:22 +00:00
filter _matchType : { 'input' : 'exact' , 'select' : 'exact' } , // global query settings ('exact' or 'match'); overridden by "filter-match" or "filter-exact" class
2015-07-23 04:29:51 +00:00
filter _onlyAvail : 'filter-onlyAvail' , // a header with a select dropdown & this class name will only show available ( visible ) options within the drop down
filter _placeholder : { search : '' , select : '' } , // default placeholder text ( overridden by any header 'data-placeholder' setting )
filter _reset : null , // jQuery selector string of an element used to reset the filters
2016-01-15 13:52:22 +00:00
filter _resetOnEsc : true , // Reset filter input when the user presses escape - normalized across browsers
2015-07-23 04:29:51 +00:00
filter _saveFilters : false , // Use the $.tablesorter.storage utility to save the most recent filters
filter _searchDelay : 300 , // typing delay in milliseconds before starting a search
filter _searchFiltered : true , // allow searching through already filtered rows in special circumstances; will speed up searching in large tables if true
filter _selectSource : null , // include a function to return an array of values to be added to the column filter select
2016-05-17 00:09:45 +00:00
filter _selectSourceSeparator : '|' , // filter_selectSource array text left of the separator is added to the option value, right into the option text
2015-07-23 04:29:51 +00:00
filter _serversideFiltering : false , // if true, must perform server-side filtering b/c client-side filtering is disabled, but the ui and events will still be used.
2016-05-17 00:09:45 +00:00
filter _startsWith : false , // if true, filter start from the beginning of the cell contents
filter _useParsedData : false // filter all data using parsed content
2015-07-23 04:29:51 +00:00
} ,
format : function ( table , c , wo ) {
if ( ! c . $table . hasClass ( 'hasFilters' ) ) {
2015-08-23 18:22:56 +00:00
tsf . init ( table , c , wo ) ;
2015-07-23 04:29:51 +00:00
}
} ,
remove : function ( table , c , wo , refreshing ) {
var tbodyIndex , $tbody ,
$table = c . $table ,
$tbodies = c . $tbodies ,
2017-07-04 17:56:45 +00:00
events = (
'addRows updateCell update updateRows updateComplete appendCache filterReset ' +
'filterAndSortReset filterFomatterUpdate filterEnd search stickyHeadersInit '
) . split ( ' ' ) . join ( c . namespace + 'filter ' ) ;
2015-07-23 04:29:51 +00:00
$table
. removeClass ( 'hasFilters' )
2015-08-26 12:22:48 +00:00
// add filter namespace to all BUT search
2015-08-23 18:22:56 +00:00
. unbind ( events . replace ( ts . regex . spaces , ' ' ) )
2015-07-23 04:29:51 +00:00
// remove the filter row even if refreshing, because the column might have been moved
. find ( '.' + tscss . filterRow ) . remove ( ) ;
2016-04-30 02:32:47 +00:00
wo . filter _initialized = false ;
2015-07-23 04:29:51 +00:00
if ( refreshing ) { return ; }
for ( tbodyIndex = 0 ; tbodyIndex < $tbodies . length ; tbodyIndex ++ ) {
$tbody = ts . processTbody ( table , $tbodies . eq ( tbodyIndex ) , true ) ; // remove tbody
$tbody . children ( ) . removeClass ( wo . filter _filteredRow ) . show ( ) ;
ts . processTbody ( table , $tbody , false ) ; // restore tbody
}
if ( wo . filter _reset ) {
2015-08-26 12:22:48 +00:00
$ ( document ) . undelegate ( wo . filter _reset , 'click' + c . namespace + 'filter' ) ;
2015-07-23 04:29:51 +00:00
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ) ;
2015-08-23 18:22:56 +00:00
tsf = ts . filter = {
2015-07-23 04:29:51 +00:00
// regex used in filter 'check' functions - not for general use and not documented
regex : {
2016-08-01 01:48:27 +00:00
regex : /^\/((?:\\\/|[^\/])+)\/([migyu]{0,5})?$/ , // regex to test for regex
2015-07-23 04:29:51 +00:00
child : /tablesorter-childRow/ , // child row class name; this gets updated in the script
filtered : /filtered/ , // filtered (hidden) row class name; updated in the script
type : /undefined|number/ , // check type
exact : /(^[\"\'=]+)|([\"\'=]+$)/g , // exact match (allow '==')
operators : /[<>=]/g , // replace operators
2015-08-23 18:22:56 +00:00
query : '(q|query)' , // replace filter queries
wild01 : /\?/g , // wild card match 0 or 1
wild0More : /\*/g , // wild care match 0 or more
quote : /\"/g ,
isNeg1 : /(>=?\s*-\d)/ ,
isNeg2 : /(<=?\s*\d)/
2015-07-23 04:29:51 +00:00
} ,
2015-03-28 20:03:50 +00:00
// function( c, data ) { }
// c = table.config
2015-05-17 20:32:53 +00:00
// data.$row = jQuery object of the row currently being processed
// data.$cells = jQuery object of all cells within the current row
// data.filters = array of filters for all columns ( some may be undefined )
// data.filter = filter for the current column
// data.iFilter = same as data.filter, except lowercase ( if wo.filter_ignoreCase is true )
2015-10-04 14:26:07 +00:00
// data.exact = table cell text ( or parsed data if column parser enabled; may be a number & not a string )
// data.iExact = same as data.exact, except lowercase ( if wo.filter_ignoreCase is true; may be a number & not a string )
2015-05-17 20:32:53 +00:00
// data.cache = table cell text from cache, so it has been parsed ( & in all lower case if c.ignoreCase is true )
// data.cacheArray = An array of parsed content from each table cell in the row being processed
// data.index = column index; table = table element ( DOM )
// data.parsed = array ( by column ) of boolean values ( from filter_useParsedData or 'filter-parsed' class )
2015-07-23 04:29:51 +00:00
types : {
or : function ( c , data , vars ) {
2015-11-10 21:27:30 +00:00
// look for "|", but not if it is inside of a regular expression
if ( ( tsfRegex . orTest . test ( data . iFilter ) || tsfRegex . orSplit . test ( data . filter ) ) &&
// this test for regex has potential to slow down the overall search
! tsfRegex . regex . test ( data . filter ) ) {
2015-07-28 20:57:01 +00:00
var indx , filterMatched , query , regex ,
2015-07-23 04:29:51 +00:00
// duplicate data but split filter
data2 = $ . extend ( { } , data ) ,
2015-11-10 21:27:30 +00:00
filter = data . filter . split ( tsfRegex . orSplit ) ,
iFilter = data . iFilter . split ( tsfRegex . orSplit ) ,
2015-07-23 04:29:51 +00:00
len = filter . length ;
for ( indx = 0 ; indx < len ; indx ++ ) {
data2 . nestedFilters = true ;
2015-11-10 21:27:30 +00:00
data2 . filter = '' + ( tsf . parseFilter ( c , filter [ indx ] , data ) || '' ) ;
data2 . iFilter = '' + ( tsf . parseFilter ( c , iFilter [ indx ] , data ) || '' ) ;
query = '(' + ( tsf . parseFilter ( c , data2 . filter , data ) || '' ) + ')' ;
2015-07-27 23:49:30 +00:00
try {
// use try/catch, because query may not be a valid regex if "|" is contained within a partial regex search,
// e.g "/(Alex|Aar" -> Uncaught SyntaxError: Invalid regular expression: /(/(Alex)/: Unterminated group
regex = new RegExp ( data . isMatch ? query : '^' + query + '$' , c . widgetOptions . filter _ignoreCase ? 'i' : '' ) ;
// filterMatched = data2.filter === '' && indx > 0 ? true
// look for an exact match with the 'or' unless the 'filter-match' class is found
2015-08-23 18:22:56 +00:00
filterMatched = regex . test ( data2 . exact ) || tsf . processTypes ( c , data2 , vars ) ;
2015-07-27 23:49:30 +00:00
if ( filterMatched ) {
return filterMatched ;
}
} catch ( error ) {
return null ;
2015-07-23 04:29:51 +00:00
}
2015-06-13 01:24:36 +00:00
}
2015-07-23 04:29:51 +00:00
// may be null from processing types
return filterMatched || false ;
2015-06-13 01:24:36 +00:00
}
2015-07-23 04:29:51 +00:00
return null ;
} ,
// Look for an AND or && operator ( logical and )
and : function ( c , data , vars ) {
2015-11-10 21:27:30 +00:00
if ( tsfRegex . andTest . test ( data . filter ) ) {
2015-07-28 20:57:01 +00:00
var indx , filterMatched , result , query , regex ,
2015-07-23 04:29:51 +00:00
// duplicate data but split filter
data2 = $ . extend ( { } , data ) ,
2015-11-10 21:27:30 +00:00
filter = data . filter . split ( tsfRegex . andSplit ) ,
iFilter = data . iFilter . split ( tsfRegex . andSplit ) ,
2015-07-23 04:29:51 +00:00
len = filter . length ;
for ( indx = 0 ; indx < len ; indx ++ ) {
data2 . nestedFilters = true ;
2015-11-10 21:27:30 +00:00
data2 . filter = '' + ( tsf . parseFilter ( c , filter [ indx ] , data ) || '' ) ;
data2 . iFilter = '' + ( tsf . parseFilter ( c , iFilter [ indx ] , data ) || '' ) ;
query = ( '(' + ( tsf . parseFilter ( c , data2 . filter , data ) || '' ) + ')' )
2015-07-23 04:29:51 +00:00
// replace wild cards since /(a*)/i will match anything
2015-11-10 21:27:30 +00:00
. replace ( tsfRegex . wild01 , '\\S{1}' ) . replace ( tsfRegex . wild0More , '\\S*' ) ;
2015-07-27 23:49:30 +00:00
try {
// use try/catch just in case RegExp is invalid
regex = new RegExp ( data . isMatch ? query : '^' + query + '$' , c . widgetOptions . filter _ignoreCase ? 'i' : '' ) ;
// look for an exact match with the 'and' unless the 'filter-match' class is found
2015-08-23 18:22:56 +00:00
result = ( regex . test ( data2 . exact ) || tsf . processTypes ( c , data2 , vars ) ) ;
2015-07-27 23:49:30 +00:00
if ( indx === 0 ) {
filterMatched = result ;
} else {
filterMatched = filterMatched && result ;
}
} catch ( error ) {
return null ;
2015-07-23 04:29:51 +00:00
}
2015-06-13 01:24:36 +00:00
}
2015-07-23 04:29:51 +00:00
// may be null from processing types
return filterMatched || false ;
2015-06-13 01:24:36 +00:00
}
2015-07-23 04:29:51 +00:00
return null ;
} ,
// Look for regex
regex : function ( c , data ) {
2015-11-10 21:27:30 +00:00
if ( tsfRegex . regex . test ( data . filter ) ) {
2015-07-23 04:29:51 +00:00
var matches ,
// cache regex per column for optimal speed
2015-11-10 21:27:30 +00:00
regex = data . filter _regexCache [ data . index ] || tsfRegex . regex . exec ( data . filter ) ,
2015-07-23 04:29:51 +00:00
isRegex = regex instanceof RegExp ;
try {
if ( ! isRegex ) {
// force case insensitive search if ignoreCase option set?
// if ( c.ignoreCase && !regex[2] ) { regex[2] = 'i'; }
data . filter _regexCache [ data . index ] = regex = new RegExp ( regex [ 1 ] , regex [ 2 ] ) ;
}
matches = regex . test ( data . exact ) ;
} catch ( error ) {
matches = false ;
2015-05-06 04:44:06 +00:00
}
2015-07-23 04:29:51 +00:00
return matches ;
2015-05-17 20:32:53 +00:00
}
2015-07-23 04:29:51 +00:00
return null ;
} ,
// Look for operators >, >=, < or <=
operators : function ( c , data ) {
// ignore empty strings... because '' < 10 is true
2015-11-10 21:27:30 +00:00
if ( tsfRegex . operTest . test ( data . iFilter ) && data . iExact !== '' ) {
2015-07-23 04:29:51 +00:00
var cachedValue , result , txt ,
table = c . table ,
2015-11-10 21:27:30 +00:00
parsed = data . parsed [ data . index ] ,
query = ts . formatFloat ( data . iFilter . replace ( tsfRegex . operators , '' ) , table ) ,
2015-12-13 22:24:42 +00:00
parser = c . parsers [ data . index ] || { } ,
2015-07-23 04:29:51 +00:00
savedSearch = query ;
// parse filter value in case we're comparing numbers ( dates )
if ( parsed || parser . type === 'numeric' ) {
2015-11-10 21:27:30 +00:00
txt = $ . trim ( '' + data . iFilter . replace ( tsfRegex . operators , '' ) ) ;
result = tsf . parseFilter ( c , txt , data , true ) ;
2015-07-23 04:29:51 +00:00
query = ( typeof result === 'number' && result !== '' && ! isNaN ( result ) ) ? result : query ;
}
// iExact may be numeric - see issue #149;
// check if cached is defined, because sometimes j goes out of range? ( numeric columns )
if ( ( parsed || parser . type === 'numeric' ) && ! isNaN ( query ) &&
typeof data . cache !== 'undefined' ) {
cachedValue = data . cache ;
} else {
2015-08-23 18:22:56 +00:00
txt = isNaN ( data . iExact ) ? data . iExact . replace ( ts . regex . nondigit , '' ) : data . iExact ;
2015-07-23 04:29:51 +00:00
cachedValue = ts . formatFloat ( txt , table ) ;
}
2015-11-10 21:27:30 +00:00
if ( tsfRegex . gtTest . test ( data . iFilter ) ) {
result = tsfRegex . gteTest . test ( data . iFilter ) ? cachedValue >= query : cachedValue > query ;
} else if ( tsfRegex . ltTest . test ( data . iFilter ) ) {
result = tsfRegex . lteTest . test ( data . iFilter ) ? cachedValue <= query : cachedValue < query ;
2015-07-23 04:29:51 +00:00
}
// keep showing all rows if nothing follows the operator
if ( ! result && savedSearch === '' ) {
result = true ;
}
return result ;
2015-05-17 20:32:53 +00:00
}
2015-07-23 04:29:51 +00:00
return null ;
} ,
// Look for a not match
notMatch : function ( c , data ) {
2015-11-10 21:27:30 +00:00
if ( tsfRegex . notTest . test ( data . iFilter ) ) {
2015-07-23 04:29:51 +00:00
var indx ,
txt = data . iFilter . replace ( '!' , '' ) ,
2015-11-10 21:27:30 +00:00
filter = tsf . parseFilter ( c , txt , data ) || '' ;
if ( tsfRegex . exact . test ( filter ) ) {
2015-07-23 04:29:51 +00:00
// look for exact not matches - see #628
2015-11-10 21:27:30 +00:00
filter = filter . replace ( tsfRegex . exact , '' ) ;
2015-07-23 04:29:51 +00:00
return filter === '' ? true : $ . trim ( filter ) !== data . iExact ;
} else {
indx = data . iExact . search ( $ . trim ( filter ) ) ;
2016-05-28 14:28:16 +00:00
return filter === '' ? true :
// return true if not found
data . anyMatch ? indx < 0 :
// return false if found
! ( c . widgetOptions . filter _startsWith ? indx === 0 : indx >= 0 ) ;
2015-07-23 04:29:51 +00:00
}
2015-05-17 20:32:53 +00:00
}
2015-07-23 04:29:51 +00:00
return null ;
} ,
// Look for quotes or equals to get an exact match; ignore type since iExact could be numeric
exact : function ( c , data ) {
/*jshint eqeqeq:false */
2015-11-10 21:27:30 +00:00
if ( tsfRegex . exact . test ( data . iFilter ) ) {
var txt = data . iFilter . replace ( tsfRegex . exact , '' ) ,
filter = tsf . parseFilter ( c , txt , data ) || '' ;
2018-03-18 13:49:07 +00:00
// eslint-disable-next-line eqeqeq
2015-07-23 04:29:51 +00:00
return data . anyMatch ? $ . inArray ( filter , data . rowArray ) >= 0 : filter == data . iExact ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
return null ;
} ,
// Look for a range ( using ' to ' or ' - ' ) - see issue #166; thanks matzhu!
range : function ( c , data ) {
2015-11-10 21:27:30 +00:00
if ( tsfRegex . toTest . test ( data . iFilter ) ) {
2015-07-23 04:29:51 +00:00
var result , tmp , range1 , range2 ,
table = c . table ,
index = data . index ,
parsed = data . parsed [ index ] ,
// make sure the dash is for a range and not indicating a negative number
2015-11-10 21:27:30 +00:00
query = data . iFilter . split ( tsfRegex . toSplit ) ;
2015-07-23 04:29:51 +00:00
2015-08-23 18:22:56 +00:00
tmp = query [ 0 ] . replace ( ts . regex . nondigit , '' ) || '' ;
2015-11-10 21:27:30 +00:00
range1 = ts . formatFloat ( tsf . parseFilter ( c , tmp , data ) , table ) ;
2015-08-23 18:22:56 +00:00
tmp = query [ 1 ] . replace ( ts . regex . nondigit , '' ) || '' ;
2015-11-10 21:27:30 +00:00
range2 = ts . formatFloat ( tsf . parseFilter ( c , tmp , data ) , table ) ;
2015-07-23 04:29:51 +00:00
// parse filter value in case we're comparing numbers ( dates )
2015-11-10 21:27:30 +00:00
if ( parsed || c . parsers [ index ] . type === 'numeric' ) {
2015-07-23 04:29:51 +00:00
result = c . parsers [ index ] . format ( '' + query [ 0 ] , table , c . $headers . eq ( index ) , index ) ;
range1 = ( result !== '' && ! isNaN ( result ) ) ? result : range1 ;
result = c . parsers [ index ] . format ( '' + query [ 1 ] , table , c . $headers . eq ( index ) , index ) ;
range2 = ( result !== '' && ! isNaN ( result ) ) ? result : range2 ;
}
if ( ( parsed || c . parsers [ index ] . type === 'numeric' ) && ! isNaN ( range1 ) && ! isNaN ( range2 ) ) {
result = data . cache ;
} else {
2015-08-23 18:22:56 +00:00
tmp = isNaN ( data . iExact ) ? data . iExact . replace ( ts . regex . nondigit , '' ) : data . iExact ;
2015-07-23 04:29:51 +00:00
result = ts . formatFloat ( tmp , table ) ;
}
if ( range1 > range2 ) {
tmp = range1 ; range1 = range2 ; range2 = tmp ; // swap
}
return ( result >= range1 && result <= range2 ) || ( range1 === '' || range2 === '' ) ;
2015-05-17 20:32:53 +00:00
}
2015-07-23 04:29:51 +00:00
return null ;
} ,
// Look for wild card: ? = single, * = multiple, or | = logical OR
wild : function ( c , data ) {
2015-11-10 21:27:30 +00:00
if ( tsfRegex . wildOrTest . test ( data . iFilter ) ) {
var query = '' + ( tsf . parseFilter ( c , data . iFilter , data ) || '' ) ;
2015-07-23 04:29:51 +00:00
// look for an exact match with the 'or' unless the 'filter-match' class is found
2015-11-10 21:27:30 +00:00
if ( ! tsfRegex . wildTest . test ( query ) && data . nestedFilters ) {
2015-07-23 04:29:51 +00:00
query = data . isMatch ? query : '^(' + query + ')$' ;
}
// parsing the filter may not work properly when using wildcards =/
2015-07-27 23:49:30 +00:00
try {
return new RegExp (
2015-11-10 21:27:30 +00:00
query . replace ( tsfRegex . wild01 , '\\S{1}' ) . replace ( tsfRegex . wild0More , '\\S*' ) ,
2015-07-27 23:49:30 +00:00
c . widgetOptions . filter _ignoreCase ? 'i' : ''
)
. test ( data . exact ) ;
} catch ( error ) {
return null ;
}
2015-07-23 04:29:51 +00:00
}
return null ;
} ,
// fuzzy text search; modified from https://github.com/mattyork/fuzzy ( MIT license )
fuzzy : function ( c , data ) {
2015-11-10 21:27:30 +00:00
if ( tsfRegex . fuzzyTest . test ( data . iFilter ) ) {
2015-07-23 04:29:51 +00:00
var indx ,
patternIndx = 0 ,
len = data . iExact . length ,
txt = data . iFilter . slice ( 1 ) ,
2015-11-10 21:27:30 +00:00
pattern = tsf . parseFilter ( c , txt , data ) || '' ;
2015-07-23 04:29:51 +00:00
for ( indx = 0 ; indx < len ; indx ++ ) {
if ( data . iExact [ indx ] === pattern [ patternIndx ] ) {
patternIndx += 1 ;
}
}
2015-11-10 21:27:30 +00:00
return patternIndx === pattern . length ;
2015-05-17 20:32:53 +00:00
}
2015-07-23 04:29:51 +00:00
return null ;
2015-03-28 20:03:50 +00:00
}
} ,
2016-04-30 02:32:47 +00:00
init : function ( table ) {
2015-07-23 04:29:51 +00:00
// filter language options
ts . language = $ . extend ( true , { } , {
to : 'to' ,
or : 'or' ,
and : 'and'
} , ts . language ) ;
2016-04-30 02:32:47 +00:00
var options , string , txt , $header , column , val , fxn , noSelect ,
c = table . config ,
2018-01-30 23:51:33 +00:00
wo = c . widgetOptions ,
processStr = function ( prefix , str , suffix ) {
str = str . trim ( ) ;
// don't include prefix/suffix if str is empty
return str === '' ? '' : ( prefix || '' ) + str + ( suffix || '' ) ;
} ;
2015-07-23 04:29:51 +00:00
c . $table . addClass ( 'hasFilters' ) ;
2015-12-13 22:24:42 +00:00
c . lastSearch = [ ] ;
2015-07-23 04:29:51 +00:00
// define timers so using clearTimeout won't cause an undefined error
2015-09-05 14:28:33 +00:00
wo . filter _searchTimer = null ;
2015-07-23 04:29:51 +00:00
wo . filter _initTimer = null ;
wo . filter _formatterCount = 0 ;
wo . filter _formatterInit = [ ] ;
wo . filter _anyColumnSelector = '[data-column="all"],[data-column="any"]' ;
wo . filter _multipleColumnSelector = '[data-column*="-"],[data-column*=","]' ;
2015-11-10 21:27:30 +00:00
val = '\\{' + tsfRegex . query + '\\}' ;
$ . extend ( tsfRegex , {
2015-07-23 04:29:51 +00:00
child : new RegExp ( c . cssChildRow ) ,
filtered : new RegExp ( wo . filter _filteredRow ) ,
2018-01-30 23:51:33 +00:00
alreadyFiltered : new RegExp ( '(\\s+(-' + processStr ( '|' , ts . language . or ) + processStr ( '|' , ts . language . to ) + ')\\s+)' , 'i' ) ,
toTest : new RegExp ( '\\s+(-' + processStr ( '|' , ts . language . to ) + ')\\s+' , 'i' ) ,
toSplit : new RegExp ( '(?:\\s+(?:-' + processStr ( '|' , ts . language . to ) + ')\\s+)' , 'gi' ) ,
andTest : new RegExp ( '\\s+(' + processStr ( '' , ts . language . and , '|' ) + '&&)\\s+' , 'i' ) ,
andSplit : new RegExp ( '(?:\\s+(?:' + processStr ( '' , ts . language . and , '|' ) + '&&)\\s+)' , 'gi' ) ,
orTest : new RegExp ( '(\\|' + processStr ( '|\\s+' , ts . language . or , '\\s+' ) + ')' , 'i' ) ,
orSplit : new RegExp ( '(?:\\|' + processStr ( '|\\s+(?:' , ts . language . or , ')\\s+' ) + ')' , 'gi' ) ,
2015-07-23 04:29:51 +00:00
iQuery : new RegExp ( val , 'i' ) ,
2015-08-23 18:22:56 +00:00
igQuery : new RegExp ( val , 'ig' ) ,
operTest : /^[<>]=?/ ,
gtTest : />/ ,
gteTest : />=/ ,
ltTest : /</ ,
lteTest : /<=/ ,
notTest : /^\!/ ,
wildOrTest : /[\?\*\|]/ ,
wildTest : /\?\*/ ,
fuzzyTest : /^~/ ,
exactTest : /[=\"\|!]/
2015-07-23 04:29:51 +00:00
} ) ;
// don't build filter row if columnFilters is false or all columns are set to 'filter-false'
// see issue #156
val = c . $headers . filter ( '.filter-false, .parser-false' ) . length ;
if ( wo . filter _columnFilters !== false && val !== c . $headers . length ) {
// build filter row
2015-08-23 18:22:56 +00:00
tsf . buildRow ( table , c , wo ) ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
2016-03-18 15:38:01 +00:00
txt = 'addRows updateCell update updateRows updateComplete appendCache filterReset ' +
2017-04-04 10:16:26 +00:00
'filterAndSortReset filterResetSaved filterEnd search ' . split ( ' ' ) . join ( c . namespace + 'filter ' ) ;
2015-07-23 04:29:51 +00:00
c . $table . bind ( txt , function ( event , filter ) {
val = wo . filter _hideEmpty &&
$ . isEmptyObject ( c . cache ) &&
! ( c . delayInit && event . type === 'appendCache' ) ;
// hide filter row using the 'filtered' class name
c . $table . find ( '.' + tscss . filterRow ) . toggleClass ( wo . filter _filteredRow , val ) ; // fixes #450
if ( ! /(search|filter)/ . test ( event . type ) ) {
event . stopPropagation ( ) ;
2015-08-23 18:22:56 +00:00
tsf . buildDefault ( table , true ) ;
2015-03-28 20:03:50 +00:00
}
2017-04-04 10:16:26 +00:00
// Add filterAndSortReset - see #1361
if ( event . type === 'filterReset' || event . type === 'filterAndSortReset' ) {
2015-07-23 04:29:51 +00:00
c . $table . find ( '.' + tscss . filter ) . add ( wo . filter _$externalFilters ) . val ( '' ) ;
2017-04-04 10:16:26 +00:00
if ( event . type === 'filterAndSortReset' ) {
ts . sortReset ( this . config , function ( ) {
tsf . searching ( table , [ ] ) ;
} ) ;
} else {
tsf . searching ( table , [ ] ) ;
}
2016-03-18 15:38:01 +00:00
} else if ( event . type === 'filterResetSaved' ) {
ts . storage ( table , 'tablesorter-filters' , '' ) ;
2015-07-23 04:29:51 +00:00
} else if ( event . type === 'filterEnd' ) {
2015-08-23 18:22:56 +00:00
tsf . buildDefault ( table , true ) ;
2015-07-23 04:29:51 +00:00
} else {
// send false argument to force a new search; otherwise if the filter hasn't changed,
// it will return
filter = event . type === 'search' ? filter :
event . type === 'updateComplete' ? c . $table . data ( 'lastSearch' ) : '' ;
if ( /(update|add)/ . test ( event . type ) && event . type !== 'updateComplete' ) {
// force a new search since content has changed
c . lastCombinedFilter = null ;
c . lastSearch = [ ] ;
2016-08-17 17:41:10 +00:00
// update filterFormatters after update (& small delay) - Fixes #1237
2018-03-18 13:49:07 +00:00
setTimeout ( function ( ) {
2016-08-17 17:41:10 +00:00
c . $table . triggerHandler ( 'filterFomatterUpdate' ) ;
} , 100 ) ;
2015-07-23 04:29:51 +00:00
}
// pass true ( skipFirst ) to prevent the tablesorter.setFilters function from skipping the first
// input ensures all inputs are updated when a search is triggered on the table
// $( 'table' ).trigger( 'search', [...] );
2015-08-23 18:22:56 +00:00
tsf . searching ( table , filter , true ) ;
2015-03-28 20:03:50 +00:00
}
return false ;
2015-07-23 04:29:51 +00:00
} ) ;
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
// reset button/link
if ( wo . filter _reset ) {
if ( wo . filter _reset instanceof $ ) {
// reset contains a jQuery object, bind to it
wo . filter _reset . click ( function ( ) {
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'filterReset' ) ;
2015-05-17 20:32:53 +00:00
} ) ;
2015-07-23 04:29:51 +00:00
} else if ( $ ( wo . filter _reset ) . length ) {
// reset is a jQuery selector, use event delegation
$ ( document )
2015-08-26 12:22:48 +00:00
. undelegate ( wo . filter _reset , 'click' + c . namespace + 'filter' )
. delegate ( wo . filter _reset , 'click' + c . namespace + 'filter' , function ( ) {
2015-07-23 04:29:51 +00:00
// trigger a reset event, so other functions ( filter_formatter ) know when to reset
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'filterReset' ) ;
2015-07-23 04:29:51 +00:00
} ) ;
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
if ( wo . filter _functions ) {
for ( column = 0 ; column < c . columns ; column ++ ) {
fxn = ts . getColumnData ( table , wo . filter _functions , column ) ;
if ( fxn ) {
// remove 'filter-select' from header otherwise the options added here are replaced with
// all options
$header = c . $headerIndexed [ column ] . removeClass ( 'filter-select' ) ;
// don't build select if 'filter-false' or 'parser-false' set
noSelect = ! ( $header . hasClass ( 'filter-false' ) || $header . hasClass ( 'parser-false' ) ) ;
options = '' ;
if ( fxn === true && noSelect ) {
2015-08-23 18:22:56 +00:00
tsf . buildSelect ( table , column ) ;
2015-07-23 04:29:51 +00:00
} else if ( typeof fxn === 'object' && noSelect ) {
// add custom drop down list
for ( string in fxn ) {
if ( typeof string === 'string' ) {
options += options === '' ?
'<option value="">' +
( $header . data ( 'placeholder' ) ||
$header . attr ( 'data-placeholder' ) ||
wo . filter _placeholder . select ||
''
) +
'</option>' : '' ;
val = string ;
txt = string ;
if ( string . indexOf ( wo . filter _selectSourceSeparator ) >= 0 ) {
val = string . split ( wo . filter _selectSourceSeparator ) ;
txt = val [ 1 ] ;
val = val [ 0 ] ;
}
options += '<option ' +
( txt === val ? '' : 'data-function-name="' + string + '" ' ) +
'value="' + val + '">' + txt + '</option>' ;
2015-03-28 20:03:50 +00:00
}
}
2015-07-23 04:29:51 +00:00
c . $table
. find ( 'thead' )
. find ( 'select.' + tscss . filter + '[data-column="' + column + '"]' )
. append ( options ) ;
txt = wo . filter _selectSource ;
2015-09-07 20:47:16 +00:00
fxn = typeof txt === 'function' ? true : ts . getColumnData ( table , txt , column ) ;
2015-07-23 04:29:51 +00:00
if ( fxn ) {
// updating so the extra options are appended
2015-08-23 18:22:56 +00:00
tsf . buildSelect ( c . table , column , '' , true , $header . hasClass ( wo . filter _onlyAvail ) ) ;
2015-07-23 04:29:51 +00:00
}
2015-04-08 03:12:53 +00:00
}
2015-03-28 20:03:50 +00:00
}
}
}
2015-07-23 04:29:51 +00:00
// not really updating, but if the column has both the 'filter-select' class &
// filter_functions set to true, it would append the same options twice.
2015-08-23 18:22:56 +00:00
tsf . buildDefault ( table , true ) ;
2015-03-28 20:03:50 +00:00
2015-08-23 18:22:56 +00:00
tsf . bindSearch ( table , c . $table . find ( '.' + tscss . filter ) , true ) ;
2015-07-23 04:29:51 +00:00
if ( wo . filter _external ) {
2015-08-23 18:22:56 +00:00
tsf . bindSearch ( table , wo . filter _external ) ;
2015-07-23 04:29:51 +00:00
}
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
if ( wo . filter _hideFilters ) {
2015-09-07 20:47:16 +00:00
tsf . hideFilters ( c ) ;
2015-07-23 04:29:51 +00:00
}
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
// show processing icon
if ( c . showProcessing ) {
2018-03-18 13:49:07 +00:00
txt = 'filterStart filterEnd ' . split ( ' ' ) . join ( c . namespace + 'filter-sp ' ) ;
2015-07-23 04:29:51 +00:00
c . $table
2015-08-23 18:22:56 +00:00
. unbind ( txt . replace ( ts . regex . spaces , ' ' ) )
2015-07-23 04:29:51 +00:00
. bind ( txt , function ( event , columns ) {
// only add processing to certain columns to all columns
$header = ( columns ) ?
c . $table
. find ( '.' + tscss . header )
. filter ( '[data-column]' )
. filter ( function ( ) {
return columns [ $ ( this ) . data ( 'column' ) ] !== '' ;
} ) : '' ;
ts . isProcessing ( table , event . type === 'filterStart' , columns ? $header : '' ) ;
} ) ;
}
// set filtered rows count ( intially unfiltered )
c . filteredRows = c . totalRows ;
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
// add default values
txt = 'tablesorter-initialized pagerBeforeInitialized ' . split ( ' ' ) . join ( c . namespace + 'filter ' ) ;
c . $table
2015-08-23 18:22:56 +00:00
. unbind ( txt . replace ( ts . regex . spaces , ' ' ) )
2015-07-23 04:29:51 +00:00
. bind ( txt , function ( ) {
2016-04-30 02:32:47 +00:00
tsf . completeInit ( this ) ;
2015-07-23 04:29:51 +00:00
} ) ;
// if filter widget is added after pager has initialized; then set filter init flag
if ( c . pager && c . pager . initialized && ! wo . filter _initialized ) {
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'filterFomatterUpdate' ) ;
2015-07-23 04:29:51 +00:00
setTimeout ( function ( ) {
2015-08-23 18:22:56 +00:00
tsf . filterInitComplete ( c ) ;
2015-07-23 04:29:51 +00:00
} , 100 ) ;
2016-04-30 02:32:47 +00:00
} else if ( ! wo . filter _initialized ) {
tsf . completeInit ( table ) ;
}
} ,
completeInit : function ( table ) {
// redefine 'c' & 'wo' so they update properly inside this callback
var c = table . config ,
wo = c . widgetOptions ,
filters = tsf . setDefaults ( table , c , wo ) || [ ] ;
if ( filters . length ) {
// prevent delayInit from triggering a cache build if filters are empty
if ( ! ( c . delayInit && filters . join ( '' ) === '' ) ) {
ts . setFilters ( table , filters , true ) ;
}
2015-07-23 04:29:51 +00:00
}
2016-04-30 02:32:47 +00:00
c . $table . triggerHandler ( 'filterFomatterUpdate' ) ;
// trigger init after setTimeout to prevent multiple filterStart/End/Init triggers
setTimeout ( function ( ) {
if ( ! wo . filter _initialized ) {
tsf . filterInitComplete ( c ) ;
}
} , 100 ) ;
2015-07-23 04:29:51 +00:00
} ,
2016-04-30 02:32:47 +00:00
2015-07-23 04:29:51 +00:00
// $cell parameter, but not the config, is passed to the filter_formatters,
// so we have to work with it instead
formatterUpdated : function ( $cell , column ) {
2015-10-27 22:01:07 +00:00
// prevent error if $cell is undefined - see #1056
2017-07-04 17:56:45 +00:00
var $table = $cell && $cell . closest ( 'table' ) ;
var config = $table . length && $table [ 0 ] . config ,
wo = config && config . widgetOptions ;
2015-10-27 22:01:07 +00:00
if ( wo && ! wo . filter _initialized ) {
2015-07-23 04:29:51 +00:00
// add updates by column since this function
// may be called numerous times before initialization
wo . filter _formatterInit [ column ] = 1 ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ,
filterInitComplete : function ( c ) {
var indx , len ,
wo = c . widgetOptions ,
count = 0 ,
completed = function ( ) {
wo . filter _initialized = true ;
2016-08-01 01:48:27 +00:00
// update lastSearch - it gets cleared often
c . lastSearch = c . $table . data ( 'lastSearch' ) ;
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'filterInit' , c ) ;
2016-08-01 01:48:27 +00:00
tsf . findRows ( c . table , c . lastSearch || [ ] ) ;
2018-03-18 13:49:07 +00:00
if ( ts . debug ( c , 'filter' ) ) {
console . log ( 'Filter >> Widget initialized' ) ;
}
2015-07-23 04:29:51 +00:00
} ;
if ( $ . isEmptyObject ( wo . filter _formatter ) ) {
2015-03-28 20:03:50 +00:00
completed ( ) ;
2015-07-23 04:29:51 +00:00
} else {
len = wo . filter _formatterInit . length ;
for ( indx = 0 ; indx < len ; indx ++ ) {
if ( wo . filter _formatterInit [ indx ] === 1 ) {
count ++ ;
}
}
clearTimeout ( wo . filter _initTimer ) ;
if ( ! wo . filter _initialized && count === wo . filter _formatterCount ) {
// filter widget initialized
2015-03-28 20:03:50 +00:00
completed ( ) ;
2015-07-23 04:29:51 +00:00
} else if ( ! wo . filter _initialized ) {
// fall back in case a filter_formatter doesn't call
// $.tablesorter.filter.formatterUpdated( $cell, column ), and the count is off
wo . filter _initTimer = setTimeout ( function ( ) {
completed ( ) ;
} , 500 ) ;
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ,
2015-10-18 18:21:11 +00:00
// encode or decode filters for storage; see #1026
processFilters : function ( filters , encode ) {
var indx ,
2016-06-28 12:09:18 +00:00
// fixes #1237; previously returning an encoded "filters" value
result = [ ] ,
2015-10-18 18:21:11 +00:00
mode = encode ? encodeURIComponent : decodeURIComponent ,
len = filters . length ;
for ( indx = 0 ; indx < len ; indx ++ ) {
2016-01-20 15:50:35 +00:00
if ( filters [ indx ] ) {
2016-06-28 12:09:18 +00:00
result [ indx ] = mode ( filters [ indx ] ) ;
2016-01-19 20:10:22 +00:00
}
2015-10-18 18:21:11 +00:00
}
2016-06-28 12:09:18 +00:00
return result ;
2015-10-18 18:21:11 +00:00
} ,
2015-07-23 04:29:51 +00:00
setDefaults : function ( table , c , wo ) {
var isArray , saved , indx , col , $filters ,
// get current ( default ) filters
filters = ts . getFilters ( table ) || [ ] ;
if ( wo . filter _saveFilters && ts . storage ) {
saved = ts . storage ( table , 'tablesorter-filters' ) || [ ] ;
isArray = $ . isArray ( saved ) ;
// make sure we're not just getting an empty array
if ( ! ( isArray && saved . join ( '' ) === '' || ! isArray ) ) {
2015-10-18 18:21:11 +00:00
filters = tsf . processFilters ( saved ) ;
2015-07-23 04:29:51 +00:00
}
2015-05-17 20:32:53 +00:00
}
2015-07-23 04:29:51 +00:00
// if no filters saved, then check default settings
if ( filters . join ( '' ) === '' ) {
// allow adding default setting to external filters
$filters = c . $headers . add ( wo . filter _$externalFilters )
. filter ( '[' + wo . filter _defaultAttrib + ']' ) ;
for ( indx = 0 ; indx <= c . columns ; indx ++ ) {
// include data-column='all' external filters
col = indx === c . columns ? 'all' : indx ;
2015-12-13 22:24:42 +00:00
filters [ indx ] = $filters
2015-07-23 04:29:51 +00:00
. filter ( '[data-column="' + col + '"]' )
. attr ( wo . filter _defaultAttrib ) || filters [ indx ] || '' ;
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
c . $table . data ( 'lastSearch' , filters ) ;
return filters ;
} ,
2015-11-10 21:27:30 +00:00
parseFilter : function ( c , filter , data , parsed ) {
return parsed || data . parsed [ data . index ] ?
c . parsers [ data . index ] . format ( filter , c . table , [ ] , data . index ) :
filter ;
2015-07-23 04:29:51 +00:00
} ,
buildRow : function ( table , c , wo ) {
2015-10-18 18:21:11 +00:00
var $filter , col , column , $header , makeSelect , disabled , name , ffxn , tmp ,
2015-07-23 04:29:51 +00:00
// c.columns defined in computeThIndexes()
cellFilter = wo . filter _cellFilter ,
columns = c . columns ,
arry = $ . isArray ( cellFilter ) ,
2018-01-18 23:30:03 +00:00
buildFilter = '<tr role="search" class="' + tscss . filterRow + ' ' + c . cssIgnoreRow + '">' ;
2015-07-23 04:29:51 +00:00
for ( column = 0 ; column < columns ; column ++ ) {
2015-10-18 18:21:11 +00:00
if ( c . $headerIndexed [ column ] . length ) {
// account for entire column set with colspan. See #1047
tmp = c . $headerIndexed [ column ] && c . $headerIndexed [ column ] [ 0 ] . colSpan || 0 ;
if ( tmp > 1 ) {
2015-12-13 22:24:42 +00:00
buildFilter += '<td data-column="' + column + '-' + ( column + tmp - 1 ) + '" colspan="' + tmp + '"' ;
} else {
buildFilter += '<td data-column="' + column + '"' ;
2015-10-18 18:21:11 +00:00
}
if ( arry ) {
buildFilter += ( cellFilter [ column ] ? ' class="' + cellFilter [ column ] + '"' : '' ) ;
} else {
buildFilter += ( cellFilter !== '' ? ' class="' + cellFilter + '"' : '' ) ;
}
buildFilter += '></td>' ;
2015-07-23 04:29:51 +00:00
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
c . $filters = $ ( buildFilter += '</tr>' )
. appendTo ( c . $table . children ( 'thead' ) . eq ( 0 ) )
2015-10-18 18:21:11 +00:00
. children ( 'td' ) ;
2015-07-23 04:29:51 +00:00
// build each filter input
for ( column = 0 ; column < columns ; column ++ ) {
disabled = false ;
// assuming last cell of a column is the main column
$header = c . $headerIndexed [ column ] ;
2015-10-18 18:21:11 +00:00
if ( $header && $header . length ) {
2015-12-13 22:24:42 +00:00
// $filter = c.$filters.filter( '[data-column="' + column + '"]' );
$filter = tsf . getColumnElm ( c , c . $filters , column ) ;
2015-10-18 18:21:11 +00:00
ffxn = ts . getColumnData ( table , wo . filter _functions , column ) ;
makeSelect = ( wo . filter _functions && ffxn && typeof ffxn !== 'function' ) ||
$header . hasClass ( 'filter-select' ) ;
// get data from jQuery data, metadata, headers option or header class name
col = ts . getColumnData ( table , c . headers , column ) ;
disabled = ts . getData ( $header [ 0 ] , col , 'filter' ) === 'false' ||
ts . getData ( $header [ 0 ] , col , 'parser' ) === 'false' ;
if ( makeSelect ) {
buildFilter = $ ( '<select>' ) . appendTo ( $filter ) ;
} else {
ffxn = ts . getColumnData ( table , wo . filter _formatter , column ) ;
if ( ffxn ) {
wo . filter _formatterCount ++ ;
buildFilter = ffxn ( $filter , column ) ;
// no element returned, so lets go find it
if ( buildFilter && buildFilter . length === 0 ) {
buildFilter = $filter . children ( 'input' ) ;
}
// element not in DOM, so lets attach it
if ( buildFilter && ( buildFilter . parent ( ) . length === 0 ||
( buildFilter . parent ( ) . length && buildFilter . parent ( ) [ 0 ] !== $filter [ 0 ] ) ) ) {
$filter . append ( buildFilter ) ;
}
} else {
buildFilter = $ ( '<input type="search">' ) . appendTo ( $filter ) ;
2015-07-23 04:29:51 +00:00
}
2015-10-18 18:21:11 +00:00
if ( buildFilter ) {
tmp = $header . data ( 'placeholder' ) ||
$header . attr ( 'data-placeholder' ) ||
wo . filter _placeholder . search || '' ;
buildFilter . attr ( 'placeholder' , tmp ) ;
2015-07-23 04:29:51 +00:00
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
if ( buildFilter ) {
2015-10-18 18:21:11 +00:00
// add filter class name
name = ( $ . isArray ( wo . filter _cssFilter ) ?
( typeof wo . filter _cssFilter [ column ] !== 'undefined' ? wo . filter _cssFilter [ column ] || '' : '' ) :
wo . filter _cssFilter ) || '' ;
2015-12-13 22:24:42 +00:00
// copy data-column from table cell (it will include colspan)
2018-01-18 23:30:03 +00:00
buildFilter . addClass ( tscss . filter + ' ' + name ) ;
name = wo . filter _filterLabel ;
tmp = name . match ( /{{([^}]+?)}}/g ) ;
if ( ! tmp ) {
2018-01-30 23:51:33 +00:00
tmp = [ '{{label}}' ] ;
2018-01-18 23:30:03 +00:00
}
$ . each ( tmp , function ( indx , attr ) {
var regex = new RegExp ( attr , 'g' ) ,
data = $header . attr ( 'data-' + attr . replace ( /{{|}}/g , '' ) ) ,
text = typeof data === 'undefined' ? $header . text ( ) : data ;
name = name . replace ( regex , $ . trim ( text ) ) ;
} ) ;
buildFilter . attr ( {
'data-column' : $filter . attr ( 'data-column' ) ,
'aria-label' : name
} ) ;
2015-10-18 18:21:11 +00:00
if ( disabled ) {
buildFilter . attr ( 'placeholder' , '' ) . addClass ( tscss . filterDisabled ) [ 0 ] . disabled = true ;
}
2015-07-23 04:29:51 +00:00
}
2015-03-28 20:03:50 +00:00
}
}
2015-07-23 04:29:51 +00:00
} ,
bindSearch : function ( table , $el , internal ) {
table = $ ( table ) [ 0 ] ;
$el = $ ( $el ) ; // allow passing a selector string
if ( ! $el . length ) { return ; }
var tmp ,
c = table . config ,
wo = c . widgetOptions ,
namespace = c . namespace + 'filter' ,
$ext = wo . filter _$externalFilters ;
if ( internal !== true ) {
// save anyMatch element
tmp = wo . filter _anyColumnSelector + ',' + wo . filter _multipleColumnSelector ;
wo . filter _$anyMatch = $el . filter ( tmp ) ;
if ( $ext && $ext . length ) {
wo . filter _$externalFilters = wo . filter _$externalFilters . add ( $el ) ;
} else {
wo . filter _$externalFilters = $el ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
// update values ( external filters added after table initialization )
ts . setFilters ( table , c . $table . data ( 'lastSearch' ) || [ ] , internal === false ) ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
// unbind events
2016-01-15 13:52:22 +00:00
tmp = ( 'keypress keyup keydown search change input ' . split ( ' ' ) . join ( namespace + ' ' ) ) ;
2015-07-23 04:29:51 +00:00
$el
// use data attribute instead of jQuery data since the head is cloned without including
// the data/binding
. attr ( 'data-lastSearchTime' , new Date ( ) . getTime ( ) )
2015-08-23 18:22:56 +00:00
. unbind ( tmp . replace ( ts . regex . spaces , ' ' ) )
2016-01-15 13:52:22 +00:00
. bind ( 'keydown' + namespace , function ( event ) {
2016-07-11 12:42:19 +00:00
if ( event . which === tskeyCodes . escape && ! table . config . widgetOptions . filter _resetOnEsc ) {
2016-01-15 13:52:22 +00:00
// prevent keypress event
return false ;
}
} )
2015-07-23 04:29:51 +00:00
. bind ( 'keyup' + namespace , function ( event ) {
2016-07-11 12:42:19 +00:00
wo = table . config . widgetOptions ; // make sure "wo" isn't cached
2016-08-17 17:41:10 +00:00
var column = parseInt ( $ ( this ) . attr ( 'data-column' ) , 10 ) ,
liveSearch = typeof wo . filter _liveSearch === 'boolean' ? wo . filter _liveSearch :
ts . getColumnData ( table , wo . filter _liveSearch , column ) ;
if ( typeof liveSearch === 'undefined' ) {
liveSearch = wo . filter _liveSearch . fallback || false ;
}
2015-07-23 04:29:51 +00:00
$ ( this ) . attr ( 'data-lastSearchTime' , new Date ( ) . getTime ( ) ) ;
// emulate what webkit does.... escape clears the filter
2016-01-15 13:52:22 +00:00
if ( event . which === tskeyCodes . escape ) {
// make sure to restore the last value on escape
this . value = wo . filter _resetOnEsc ? '' : c . lastSearch [ column ] ;
2015-07-23 04:29:51 +00:00
// don't return if the search value is empty ( all rows need to be revealed )
} else if ( this . value !== '' && (
// liveSearch can contain a min value length; ignore arrow and meta keys, but allow backspace
2016-08-17 17:41:10 +00:00
( typeof liveSearch === 'number' && this . value . length < liveSearch ) ||
2015-07-23 04:29:51 +00:00
// let return & backspace continue on, but ignore arrows & non-valid characters
2016-01-15 13:52:22 +00:00
( event . which !== tskeyCodes . enter && event . which !== tskeyCodes . backSpace &&
( event . which < tskeyCodes . space || ( event . which >= tskeyCodes . left && event . which <= tskeyCodes . down ) ) ) ) ) {
2015-07-23 04:29:51 +00:00
return ;
2017-05-24 23:53:44 +00:00
// live search
} else if ( liveSearch === false ) {
if ( this . value !== '' && event . which !== tskeyCodes . enter ) {
return ;
}
2015-07-23 04:29:51 +00:00
}
// change event = no delay; last true flag tells getFilters to skip newest timed input
2016-12-08 13:48:07 +00:00
tsf . searching ( table , true , true , column ) ;
2015-07-23 04:29:51 +00:00
} )
2016-01-15 13:52:22 +00:00
// include change for select - fixes #473
2017-05-24 23:53:44 +00:00
. bind ( 'search change keypress input blur ' . split ( ' ' ) . join ( namespace + ' ' ) , function ( event ) {
2015-08-21 17:57:54 +00:00
// don't get cached data, in case data-column changes dynamically
2016-11-27 01:40:00 +00:00
var column = parseInt ( $ ( this ) . attr ( 'data-column' ) , 10 ) ,
2017-05-24 23:53:44 +00:00
eventType = event . type ,
2016-11-27 01:40:00 +00:00
liveSearch = typeof wo . filter _liveSearch === 'boolean' ?
wo . filter _liveSearch :
ts . getColumnData ( table , wo . filter _liveSearch , column ) ;
2016-07-11 12:42:19 +00:00
if ( table . config . widgetOptions . filter _initialized &&
2016-12-08 13:48:07 +00:00
// immediate search if user presses enter
( event . which === tskeyCodes . enter ||
2017-05-24 23:53:44 +00:00
// immediate search if a "search" or "blur" is triggered on the input
( eventType === 'search' || eventType === 'blur' ) ||
2016-12-08 13:48:07 +00:00
// change & input events must be ignored if liveSearch !== true
2017-05-24 23:53:44 +00:00
( eventType === 'change' || eventType === 'input' ) &&
2016-12-08 13:48:07 +00:00
// prevent search if liveSearch is a number
2017-05-26 20:11:58 +00:00
( liveSearch === true || liveSearch !== true && event . target . nodeName !== 'INPUT' ) &&
2016-12-08 13:48:07 +00:00
// don't allow 'change' or 'input' event to process if the input value
// is the same - fixes #685
this . value !== c . lastSearch [ column ]
)
2016-09-23 16:45:10 +00:00
) {
2015-07-23 04:29:51 +00:00
event . preventDefault ( ) ;
// init search with no delay
$ ( this ) . attr ( 'data-lastSearchTime' , new Date ( ) . getTime ( ) ) ;
2017-05-24 23:53:44 +00:00
tsf . searching ( table , eventType !== 'keypress' , true , column ) ;
2015-07-23 04:29:51 +00:00
}
} ) ;
} ,
2016-08-17 17:41:10 +00:00
searching : function ( table , filter , skipFirst , column ) {
var liveSearch ,
wo = table . config . widgetOptions ;
if ( typeof column === 'undefined' ) {
// no delay
liveSearch = false ;
} else {
liveSearch = typeof wo . filter _liveSearch === 'boolean' ?
wo . filter _liveSearch :
// get column setting, or set to fallback value, or default to false
ts . getColumnData ( table , wo . filter _liveSearch , column ) ;
2016-12-08 13:48:07 +00:00
if ( typeof liveSearch === 'undefined' ) {
2016-08-17 17:41:10 +00:00
liveSearch = wo . filter _liveSearch . fallback || false ;
}
}
2015-09-05 14:28:33 +00:00
clearTimeout ( wo . filter _searchTimer ) ;
2015-07-23 04:29:51 +00:00
if ( typeof filter === 'undefined' || filter === true ) {
// delay filtering
2015-09-05 14:28:33 +00:00
wo . filter _searchTimer = setTimeout ( function ( ) {
2015-08-23 18:22:56 +00:00
tsf . checkFilters ( table , filter , skipFirst ) ;
2016-08-17 17:41:10 +00:00
} , liveSearch ? wo . filter _searchDelay : 10 ) ;
2015-03-28 20:03:50 +00:00
} else {
2015-07-23 04:29:51 +00:00
// skip delay
2015-08-23 18:22:56 +00:00
tsf . checkFilters ( table , filter , skipFirst ) ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ,
2017-04-19 00:50:08 +00:00
equalFilters : function ( c , filter1 , filter2 ) {
var indx ,
f1 = [ ] ,
f2 = [ ] ,
len = c . columns + 1 ; // add one to include anyMatch filter
filter1 = $ . isArray ( filter1 ) ? filter1 : [ ] ;
filter2 = $ . isArray ( filter2 ) ? filter2 : [ ] ;
for ( indx = 0 ; indx < len ; indx ++ ) {
f1 [ indx ] = filter1 [ indx ] || '' ;
f2 [ indx ] = filter2 [ indx ] || '' ;
}
return f1 . join ( ',' ) === f2 . join ( ',' ) ;
} ,
2015-07-23 04:29:51 +00:00
checkFilters : function ( table , filter , skipFirst ) {
var c = table . config ,
wo = c . widgetOptions ,
filterArray = $ . isArray ( filter ) ,
filters = ( filterArray ) ? filter : ts . getFilters ( table , true ) ,
2017-04-02 11:33:20 +00:00
currentFilters = filters || [ ] ; // current filter values
2015-07-23 04:29:51 +00:00
// prevent errors if delay init is set
if ( $ . isEmptyObject ( c . cache ) ) {
// update cache if delayInit set & pager has initialized ( after user initiates a search )
2016-03-18 15:38:01 +00:00
if ( c . delayInit && ( ! c . pager || c . pager && c . pager . initialized ) ) {
2015-10-22 21:41:34 +00:00
ts . updateCache ( c , function ( ) {
2015-08-23 18:22:56 +00:00
tsf . checkFilters ( table , false , skipFirst ) ;
2015-10-22 21:41:34 +00:00
} ) ;
2015-07-23 04:29:51 +00:00
}
2015-03-28 20:03:50 +00:00
return ;
}
2015-07-23 04:29:51 +00:00
// add filter array back into inputs
if ( filterArray ) {
ts . setFilters ( table , filters , false , skipFirst !== true ) ;
2017-04-02 11:33:20 +00:00
if ( ! wo . filter _initialized ) {
c . lastSearch = [ ] ;
c . lastCombinedFilter = '' ;
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
if ( wo . filter _hideFilters ) {
// show/hide filter row as needed
c . $table
. find ( '.' + tscss . filterRow )
2016-07-11 12:42:19 +00:00
. triggerHandler ( tsf . hideFiltersCheck ( c ) ? 'mouseleave' : 'mouseenter' ) ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
// return if the last search is the same; but filter === false when updating the search
// see example-widget-filter.html filter toggle buttons
2017-04-19 00:50:08 +00:00
if ( tsf . equalFilters ( c , c . lastSearch , currentFilters ) && filter !== false ) {
2015-07-23 04:29:51 +00:00
return ;
} else if ( filter === false ) {
// force filter refresh
2017-04-02 11:33:20 +00:00
c . lastCombinedFilter = '' ;
2015-07-23 04:29:51 +00:00
c . lastSearch = [ ] ;
}
2015-12-02 01:38:56 +00:00
// define filter inside it is false
filters = filters || [ ] ;
2015-11-06 19:41:19 +00:00
// convert filters to strings - see #1070
filters = Array . prototype . map ?
filters . map ( String ) :
// for IE8 & older browsers - maybe not the best method
2016-01-11 04:22:16 +00:00
filters . join ( '\ufffd' ) . split ( '\ufffd' ) ;
2015-11-06 19:41:19 +00:00
2015-07-23 04:29:51 +00:00
if ( wo . filter _initialized ) {
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'filterStart' , [ filters ] ) ;
2015-07-23 04:29:51 +00:00
}
if ( c . showProcessing ) {
// give it time for the processing icon to kick in
setTimeout ( function ( ) {
2017-04-02 11:33:20 +00:00
tsf . findRows ( table , filters , currentFilters ) ;
2015-07-23 04:29:51 +00:00
return false ;
} , 30 ) ;
} else {
2017-04-02 11:33:20 +00:00
tsf . findRows ( table , filters , currentFilters ) ;
2015-03-28 20:03:50 +00:00
return false ;
2015-07-23 04:29:51 +00:00
}
} ,
2016-07-11 12:42:19 +00:00
hideFiltersCheck : function ( c ) {
if ( typeof c . widgetOptions . filter _hideFilters === 'function' ) {
var val = c . widgetOptions . filter _hideFilters ( c ) ;
if ( typeof val === 'boolean' ) {
return val ;
}
}
return ts . getFilters ( c . $table ) . join ( '' ) === '' ;
} ,
2015-10-18 18:21:11 +00:00
hideFilters : function ( c , $table ) {
2016-07-11 12:42:19 +00:00
var timer ;
( $table || c . $table )
. find ( '.' + tscss . filterRow )
. addClass ( tscss . filterRowHide )
2015-07-23 04:29:51 +00:00
. bind ( 'mouseenter mouseleave' , function ( e ) {
// save event object - http://bugs.jquery.com/ticket/12140
var event = e ,
2016-07-11 12:42:19 +00:00
$row = $ ( this ) ;
2015-07-23 04:29:51 +00:00
clearTimeout ( timer ) ;
timer = setTimeout ( function ( ) {
if ( /enter|over/ . test ( event . type ) ) {
2016-07-11 12:42:19 +00:00
$row . removeClass ( tscss . filterRowHide ) ;
2015-07-23 04:29:51 +00:00
} else {
// don't hide if input has focus
// $( ':focus' ) needs jQuery 1.6+
2016-07-11 12:42:19 +00:00
if ( $ ( document . activeElement ) . closest ( 'tr' ) [ 0 ] !== $row [ 0 ] ) {
2015-07-23 04:29:51 +00:00
// don't hide row if any filter has a value
2016-07-11 12:42:19 +00:00
$row . toggleClass ( tscss . filterRowHide , tsf . hideFiltersCheck ( c ) ) ;
2015-03-28 20:03:50 +00:00
}
}
2015-07-23 04:29:51 +00:00
} , 200 ) ;
} )
. find ( 'input, select' ) . bind ( 'focus blur' , function ( e ) {
var event = e ,
$row = $ ( this ) . closest ( 'tr' ) ;
2015-06-13 02:06:08 +00:00
clearTimeout ( timer ) ;
2015-07-23 04:29:51 +00:00
timer = setTimeout ( function ( ) {
clearTimeout ( timer ) ;
// don't hide row if any filter has a value
2016-07-11 12:42:19 +00:00
$row . toggleClass ( tscss . filterRowHide , tsf . hideFiltersCheck ( c ) && event . type !== 'focus' ) ;
2015-07-23 04:29:51 +00:00
} , 200 ) ;
} ) ;
} ,
defaultFilter : function ( filter , mask ) {
if ( filter === '' ) { return filter ; }
2015-11-10 21:27:30 +00:00
var regex = tsfRegex . iQuery ,
maskLen = mask . match ( tsfRegex . igQuery ) . length ,
2015-07-23 04:29:51 +00:00
query = maskLen > 1 ? $ . trim ( filter ) . split ( /\s/ ) : [ $ . trim ( filter ) ] ,
len = query . length - 1 ,
indx = 0 ,
val = mask ;
if ( len < 1 && maskLen > 1 ) {
// only one 'word' in query but mask has >1 slots
query [ 1 ] = query [ 0 ] ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
// replace all {query} with query words...
// if query = 'Bob', then convert mask from '!{query}' to '!Bob'
// if query = 'Bob Joe Frank', then convert mask '{q} OR {q}' to 'Bob OR Joe OR Frank'
while ( regex . test ( val ) ) {
val = val . replace ( regex , query [ indx ++ ] || '' ) ;
if ( regex . test ( val ) && indx < len && ( query [ indx ] || '' ) !== '' ) {
val = mask . replace ( regex , val ) ;
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
return val ;
} ,
getLatestSearch : function ( $input ) {
if ( $input ) {
return $input . sort ( function ( a , b ) {
return $ ( b ) . attr ( 'data-lastSearchTime' ) - $ ( a ) . attr ( 'data-lastSearchTime' ) ;
} ) ;
}
return $input || $ ( ) ;
} ,
2015-12-13 22:24:42 +00:00
findRange : function ( c , val , ignoreRanges ) {
2015-07-23 04:29:51 +00:00
// look for multiple columns '1-3,4-6,8' in data-column
var temp , ranges , range , start , end , singles , i , indx , len ,
2015-12-13 22:24:42 +00:00
columns = [ ] ;
if ( /^[0-9]+$/ . test ( val ) ) {
// always return an array
return [ parseInt ( val , 10 ) ] ;
2015-08-21 17:57:54 +00:00
}
2015-07-23 04:29:51 +00:00
// process column range
2015-12-13 22:24:42 +00:00
if ( ! ignoreRanges && /-/ . test ( val ) ) {
2015-07-23 04:29:51 +00:00
ranges = val . match ( /(\d+)\s*-\s*(\d+)/g ) ;
2015-12-13 22:24:42 +00:00
len = ranges ? ranges . length : 0 ;
2015-07-23 04:29:51 +00:00
for ( indx = 0 ; indx < len ; indx ++ ) {
range = ranges [ indx ] . split ( /\s*-\s*/ ) ;
start = parseInt ( range [ 0 ] , 10 ) || 0 ;
end = parseInt ( range [ 1 ] , 10 ) || ( c . columns - 1 ) ;
if ( start > end ) {
temp = start ; start = end ; end = temp ; // swap
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
if ( end >= c . columns ) {
end = c . columns - 1 ;
}
for ( ; start <= end ; start ++ ) {
2016-03-02 05:00:22 +00:00
columns [ columns . length ] = start ;
2015-07-23 04:29:51 +00:00
}
// remove processed range from val
val = val . replace ( ranges [ indx ] , '' ) ;
2015-03-28 20:03:50 +00:00
}
}
2015-07-23 04:29:51 +00:00
// process single columns
2015-12-13 22:24:42 +00:00
if ( ! ignoreRanges && /,/ . test ( val ) ) {
2015-07-23 04:29:51 +00:00
singles = val . split ( /\s*,\s*/ ) ;
len = singles . length ;
for ( i = 0 ; i < len ; i ++ ) {
if ( singles [ i ] !== '' ) {
indx = parseInt ( singles [ i ] , 10 ) ;
if ( indx < c . columns ) {
2016-03-02 05:00:22 +00:00
columns [ columns . length ] = indx ;
2015-07-23 04:29:51 +00:00
}
}
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
// return all columns
if ( ! columns . length ) {
for ( indx = 0 ; indx < c . columns ; indx ++ ) {
2016-03-02 05:00:22 +00:00
columns [ columns . length ] = indx ;
2015-06-13 01:24:36 +00:00
}
}
2015-07-23 04:29:51 +00:00
return columns ;
} ,
2015-12-13 22:24:42 +00:00
getColumnElm : function ( c , $elements , column ) {
// data-column may contain multiple columns '1-3,5-6,8'
// replaces: c.$filters.filter( '[data-column="' + column + '"]' );
return $elements . filter ( function ( ) {
var cols = tsf . findRange ( c , $ ( this ) . attr ( 'data-column' ) ) ;
return $ . inArray ( column , cols ) > - 1 ;
} ) ;
} ,
multipleColumns : function ( c , $input ) {
// look for multiple columns '1-3,4-6,8' in data-column
var wo = c . widgetOptions ,
// only target 'all' column inputs on initialization
// & don't target 'all' column inputs if they don't exist
targets = wo . filter _initialized || ! $input . filter ( wo . filter _anyColumnSelector ) . length ,
val = $ . trim ( tsf . getLatestSearch ( $input ) . attr ( 'data-column' ) || '' ) ;
return tsf . findRange ( c , val , ! targets ) ;
} ,
2015-07-23 04:29:51 +00:00
processTypes : function ( c , data , vars ) {
var ffxn ,
filterMatched = null ,
matches = null ;
2015-08-23 18:22:56 +00:00
for ( ffxn in tsf . types ) {
2015-07-23 04:29:51 +00:00
if ( $ . inArray ( ffxn , vars . excludeMatch ) < 0 && matches === null ) {
2015-08-23 18:22:56 +00:00
matches = tsf . types [ ffxn ] ( c , data , vars ) ;
2015-07-23 04:29:51 +00:00
if ( matches !== null ) {
2017-12-13 21:17:20 +00:00
data . matchedOn = ffxn ;
2015-07-23 04:29:51 +00:00
filterMatched = matches ;
2015-05-17 20:32:53 +00:00
}
}
2015-07-23 04:29:51 +00:00
}
return filterMatched ;
} ,
2016-03-02 05:00:22 +00:00
matchType : function ( c , columnIndex ) {
var isMatch ,
2016-04-01 17:06:10 +00:00
wo = c . widgetOptions ,
2016-03-02 05:00:22 +00:00
$el = c . $headerIndexed [ columnIndex ] ;
// filter-exact > filter-match > filter_matchType for type
if ( $el . hasClass ( 'filter-exact' ) ) {
isMatch = false ;
} else if ( $el . hasClass ( 'filter-match' ) ) {
isMatch = true ;
} else {
// filter-select is not applied when filter_functions are used, so look for a select
2016-04-01 17:06:10 +00:00
if ( wo . filter _columnFilters ) {
$el = c . $filters
. find ( '.' + tscss . filter )
. add ( wo . filter _$externalFilters )
. filter ( '[data-column="' + columnIndex + '"]' ) ;
} else if ( wo . filter _$externalFilters ) {
$el = wo . filter _$externalFilters . filter ( '[data-column="' + columnIndex + '"]' ) ;
}
2016-03-02 05:00:22 +00:00
isMatch = $el . length ?
c . widgetOptions . filter _matchType [ ( $el [ 0 ] . nodeName || '' ) . toLowerCase ( ) ] === 'match' :
// default to exact, if no inputs found
false ;
}
return isMatch ;
} ,
2015-07-23 04:29:51 +00:00
processRow : function ( c , data , vars ) {
2015-11-10 21:27:30 +00:00
var result , filterMatched ,
2015-07-23 04:29:51 +00:00
fxn , ffxn , txt ,
wo = c . widgetOptions ,
2015-08-21 17:57:54 +00:00
showRow = true ,
2016-08-01 01:48:27 +00:00
hasAnyMatchInput = wo . filter _$anyMatch && wo . filter _$anyMatch . length ,
2015-08-21 17:57:54 +00:00
// if wo.filter_$anyMatch data-column attribute is changed dynamically
// we don't want to do an "anyMatch" search on one column using data
// for the entire row - see #998
columnIndex = wo . filter _$anyMatch && wo . filter _$anyMatch . length ?
// look for multiple columns '1-3,4-6,8'
2015-08-23 18:22:56 +00:00
tsf . multipleColumns ( c , wo . filter _$anyMatch ) :
2015-08-21 17:57:54 +00:00
[ ] ;
2015-07-23 04:29:51 +00:00
data . $cells = data . $row . children ( ) ;
2017-12-13 21:17:20 +00:00
data . matchedOn = null ;
2016-08-01 01:48:27 +00:00
if ( data . anyMatchFlag && columnIndex . length > 1 || ( data . anyMatchFilter && ! hasAnyMatchInput ) ) {
2015-07-23 04:29:51 +00:00
data . anyMatch = true ;
data . isMatch = true ;
data . rowArray = data . $cells . map ( function ( i ) {
2016-08-01 01:48:27 +00:00
if ( $ . inArray ( i , columnIndex ) > - 1 || ( data . anyMatchFilter && ! hasAnyMatchInput ) ) {
2015-07-23 04:29:51 +00:00
if ( data . parsed [ i ] ) {
txt = data . cacheArray [ i ] ;
} else {
txt = data . rawArray [ i ] ;
txt = $ . trim ( wo . filter _ignoreCase ? txt . toLowerCase ( ) : txt ) ;
if ( c . sortLocaleCompare ) {
txt = ts . replaceAccents ( txt ) ;
}
}
return txt ;
2015-05-17 20:32:53 +00:00
}
2015-07-23 04:29:51 +00:00
} ) . get ( ) ;
data . filter = data . anyMatchFilter ;
data . iFilter = data . iAnyMatchFilter ;
data . exact = data . rowArray . join ( ' ' ) ;
data . iExact = wo . filter _ignoreCase ? data . exact . toLowerCase ( ) : data . exact ;
data . cache = data . cacheArray . slice ( 0 , - 1 ) . join ( ' ' ) ;
vars . excludeMatch = vars . noAnyMatch ;
2015-08-23 18:22:56 +00:00
filterMatched = tsf . processTypes ( c , data , vars ) ;
2015-07-23 04:29:51 +00:00
if ( filterMatched !== null ) {
showRow = filterMatched ;
2015-05-17 20:32:53 +00:00
} else {
2015-07-23 04:29:51 +00:00
if ( wo . filter _startsWith ) {
showRow = false ;
2015-08-18 01:10:29 +00:00
// data.rowArray may not contain all columns
columnIndex = Math . min ( c . columns , data . rowArray . length ) ;
2015-07-23 04:29:51 +00:00
while ( ! showRow && columnIndex > 0 ) {
columnIndex -- ;
showRow = showRow || data . rowArray [ columnIndex ] . indexOf ( data . iFilter ) === 0 ;
}
} else {
showRow = ( data . iExact + data . childRowText ) . indexOf ( data . iFilter ) >= 0 ;
}
}
data . anyMatch = false ;
// no other filters to process
if ( data . filters . join ( '' ) === data . filter ) {
return showRow ;
2015-05-17 20:32:53 +00:00
}
}
2015-07-23 04:29:51 +00:00
for ( columnIndex = 0 ; columnIndex < c . columns ; columnIndex ++ ) {
data . filter = data . filters [ columnIndex ] ;
data . index = columnIndex ;
2015-05-17 20:32:53 +00:00
2015-07-23 04:29:51 +00:00
// filter types to exclude, per column
vars . excludeMatch = vars . excludeFilter [ columnIndex ] ;
2015-05-17 20:32:53 +00:00
2015-07-23 04:29:51 +00:00
// ignore if filter is empty or disabled
if ( data . filter ) {
data . cache = data . cacheArray [ columnIndex ] ;
2016-03-02 05:00:22 +00:00
result = data . parsed [ columnIndex ] ? data . cache : data . rawArray [ columnIndex ] || '' ;
2016-01-11 04:22:16 +00:00
data . exact = c . sortLocaleCompare ? ts . replaceAccents ( result ) : result ; // issue #405
2015-11-10 21:27:30 +00:00
data . iExact = ! tsfRegex . type . test ( typeof data . exact ) && wo . filter _ignoreCase ?
2015-07-23 04:29:51 +00:00
data . exact . toLowerCase ( ) : data . exact ;
2016-03-02 05:00:22 +00:00
data . isMatch = tsf . matchType ( c , columnIndex ) ;
2015-07-23 04:29:51 +00:00
result = showRow ; // if showRow is true, show that row
// in case select filter option has a different value vs text 'a - z|A through Z'
ffxn = wo . filter _columnFilters ?
2016-04-01 17:06:10 +00:00
c . $filters . add ( wo . filter _$externalFilters )
2015-07-23 04:29:51 +00:00
. filter ( '[data-column="' + columnIndex + '"]' )
. find ( 'select option:selected' )
. attr ( 'data-function-name' ) || '' : '' ;
// replace accents - see #357
if ( c . sortLocaleCompare ) {
data . filter = ts . replaceAccents ( data . filter ) ;
}
2015-12-02 19:36:47 +00:00
// replace column specific default filters - see #1088
if ( wo . filter _defaultFilter && tsfRegex . iQuery . test ( vars . defaultColFilter [ columnIndex ] ) ) {
data . filter = tsf . defaultFilter ( data . filter , vars . defaultColFilter [ columnIndex ] ) ;
}
2015-07-23 04:29:51 +00:00
// data.iFilter = case insensitive ( if wo.filter_ignoreCase is true ),
// data.filter = case sensitive
data . iFilter = wo . filter _ignoreCase ? ( data . filter || '' ) . toLowerCase ( ) : data . filter ;
fxn = vars . functions [ columnIndex ] ;
filterMatched = null ;
2015-11-10 21:27:30 +00:00
if ( fxn ) {
2017-05-26 20:11:58 +00:00
if ( typeof fxn === 'function' ) {
2015-07-23 04:29:51 +00:00
// filter callback( exact cell content, parser normalized content,
// filter input value, column index, jQuery row object )
filterMatched = fxn ( data . exact , data . cache , data . filter , columnIndex , data . $row , c , data ) ;
} else if ( typeof fxn [ ffxn || data . filter ] === 'function' ) {
// selector option function
txt = ffxn || data . filter ;
filterMatched =
fxn [ txt ] ( data . exact , data . cache , data . filter , columnIndex , data . $row , c , data ) ;
}
}
if ( filterMatched === null ) {
// cycle through the different filters
// filters return a boolean or null if nothing matches
2015-08-23 18:22:56 +00:00
filterMatched = tsf . processTypes ( c , data , vars ) ;
2017-12-13 21:17:20 +00:00
// select with exact match; ignore "and" or "or" within the text; fixes #1486
txt = fxn === true && ( data . matchedOn === 'and' || data . matchedOn === 'or' ) ;
if ( filterMatched !== null && ! txt ) {
2015-07-23 04:29:51 +00:00
result = filterMatched ;
// Look for match, and add child row data for matching
} else {
2017-05-26 20:11:58 +00:00
// check fxn (filter-select in header) after filter types are checked
// without this, the filter + jQuery UI selectmenu demo was breaking
if ( fxn === true ) {
// default selector uses exact match unless 'filter-match' class is found
result = data . isMatch ?
// data.iExact may be a number
( '' + data . iExact ) . search ( data . iFilter ) >= 0 :
data . filter === data . exact ;
} else {
txt = ( data . iExact + data . childRowText ) . indexOf ( tsf . parseFilter ( c , data . iFilter , data ) ) ;
result = ( ( ! wo . filter _startsWith && txt >= 0 ) || ( wo . filter _startsWith && txt === 0 ) ) ;
}
2015-07-23 04:29:51 +00:00
}
2015-05-17 20:32:53 +00:00
} else {
2015-07-23 04:29:51 +00:00
result = filterMatched ;
2015-05-17 20:32:53 +00:00
}
2015-07-23 04:29:51 +00:00
showRow = ( result ) ? showRow : false ;
2015-05-17 20:32:53 +00:00
}
}
2015-07-23 04:29:51 +00:00
return showRow ;
} ,
2017-04-02 11:33:20 +00:00
findRows : function ( table , filters , currentFilters ) {
if (
2017-04-19 00:50:08 +00:00
tsf . equalFilters ( table . config , table . config . lastSearch , currentFilters ) ||
2017-04-02 11:33:20 +00:00
! table . config . widgetOptions . filter _initialized
) {
2015-07-23 04:29:51 +00:00
return ;
}
2015-09-23 12:20:32 +00:00
var len , norm _rows , rowData , $rows , $row , rowIndex , tbodyIndex , $tbody , columnIndex ,
2015-09-24 03:46:03 +00:00
isChild , childRow , lastSearch , showRow , showParent , time , val , indx ,
2015-07-23 04:29:51 +00:00
notFiltered , searchFiltered , query , injected , res , id , txt ,
storedFilters = $ . extend ( [ ] , filters ) ,
c = table . config ,
wo = c . widgetOptions ,
2018-03-18 13:49:07 +00:00
debug = ts . debug ( c , 'filter' ) ,
2015-07-23 04:29:51 +00:00
// data object passed to filters; anyMatch is a flag for the filters
data = {
anyMatch : false ,
filters : filters ,
// regex filter type cache
filter _regexCache : [ ]
} ,
vars = {
// anyMatch really screws up with these types of filters
2016-05-28 14:28:16 +00:00
noAnyMatch : [ 'range' , 'operators' ] ,
2015-07-23 04:29:51 +00:00
// cache filter variables that use ts.getColumnData in the main loop
functions : [ ] ,
excludeFilter : [ ] ,
defaultColFilter : [ ] ,
defaultAnyFilter : ts . getColumnData ( table , wo . filter _defaultFilter , c . columns , true ) || ''
} ;
// parse columns after formatter, in case the class is added at that point
2016-01-11 04:22:16 +00:00
data . parsed = [ ] ;
for ( columnIndex = 0 ; columnIndex < c . columns ; columnIndex ++ ) {
data . parsed [ columnIndex ] = wo . filter _useParsedData ||
// parser has a "parsed" parameter
( c . parsers && c . parsers [ columnIndex ] && c . parsers [ columnIndex ] . parsed ||
// getData may not return 'parsed' if other 'filter-' class names exist
2015-07-23 04:29:51 +00:00
// ( e.g. <th class="filter-select filter-parsed"> )
ts . getData && ts . getData ( c . $headerIndexed [ columnIndex ] ,
ts . getColumnData ( table , c . headers , columnIndex ) , 'filter' ) === 'parsed' ||
2016-01-11 04:22:16 +00:00
c . $headerIndexed [ columnIndex ] . hasClass ( 'filter-parsed' ) ) ;
2015-04-07 16:25:40 +00:00
2015-07-23 04:29:51 +00:00
vars . functions [ columnIndex ] =
2016-02-15 19:15:22 +00:00
ts . getColumnData ( table , wo . filter _functions , columnIndex ) ||
c . $headerIndexed [ columnIndex ] . hasClass ( 'filter-select' ) ;
2015-07-23 04:29:51 +00:00
vars . defaultColFilter [ columnIndex ] =
ts . getColumnData ( table , wo . filter _defaultFilter , columnIndex ) || '' ;
vars . excludeFilter [ columnIndex ] =
( ts . getColumnData ( table , wo . filter _excludeFilter , columnIndex , true ) || '' ) . split ( /\s+/ ) ;
}
2018-03-18 13:49:07 +00:00
if ( debug ) {
console . log ( 'Filter >> Starting filter widget search' , filters ) ;
2015-07-23 04:29:51 +00:00
time = new Date ( ) ;
}
// filtered rows count
c . filteredRows = 0 ;
c . totalRows = 0 ;
2017-04-02 11:33:20 +00:00
currentFilters = ( storedFilters || [ ] ) ;
2015-07-23 04:29:51 +00:00
for ( tbodyIndex = 0 ; tbodyIndex < c . $tbodies . length ; tbodyIndex ++ ) {
$tbody = ts . processTbody ( table , c . $tbodies . eq ( tbodyIndex ) , true ) ;
// skip child rows & widget added ( removable ) rows - fixes #448 thanks to @hempel!
// $rows = $tbody.children( 'tr' ).not( c.selectorRemove );
columnIndex = c . columns ;
// convert stored rows into a jQuery object
norm _rows = c . cache [ tbodyIndex ] . normalized ;
$rows = $ ( $ . map ( norm _rows , function ( el ) {
return el [ columnIndex ] . $row . get ( ) ;
} ) ) ;
2017-04-02 11:33:20 +00:00
if ( currentFilters . join ( '' ) === '' || wo . filter _serversideFiltering ) {
2015-07-23 04:29:51 +00:00
$rows
. removeClass ( wo . filter _filteredRow )
. not ( '.' + c . cssChildRow )
. css ( 'display' , '' ) ;
} else {
// filter out child rows
$rows = $rows . not ( '.' + c . cssChildRow ) ;
len = $rows . length ;
if ( ( wo . filter _$anyMatch && wo . filter _$anyMatch . length ) ||
typeof filters [ c . columns ] !== 'undefined' ) {
data . anyMatchFlag = true ;
data . anyMatchFilter = '' + (
filters [ c . columns ] ||
2015-08-23 18:22:56 +00:00
wo . filter _$anyMatch && tsf . getLatestSearch ( wo . filter _$anyMatch ) . val ( ) ||
2015-07-23 04:29:51 +00:00
''
) ;
if ( wo . filter _columnAnyMatch ) {
// specific columns search
2015-11-10 21:27:30 +00:00
query = data . anyMatchFilter . split ( tsfRegex . andSplit ) ;
2015-07-23 04:29:51 +00:00
injected = false ;
for ( indx = 0 ; indx < query . length ; indx ++ ) {
res = query [ indx ] . split ( ':' ) ;
if ( res . length > 1 ) {
// make the column a one-based index ( non-developers start counting from one :P )
2016-08-22 15:41:07 +00:00
if ( isNaN ( res [ 0 ] ) ) {
$ . each ( c . headerContent , function ( i , txt ) {
// multiple matches are possible
if ( txt . toLowerCase ( ) . indexOf ( res [ 0 ] ) > - 1 ) {
id = i ;
filters [ id ] = res [ 1 ] ;
}
} ) ;
} else {
id = parseInt ( res [ 0 ] , 10 ) - 1 ;
}
2015-07-23 04:29:51 +00:00
if ( id >= 0 && id < c . columns ) { // if id is an integer
filters [ id ] = res [ 1 ] ;
query . splice ( indx , 1 ) ;
indx -- ;
injected = true ;
}
2015-03-28 20:03:50 +00:00
}
}
2015-07-23 04:29:51 +00:00
if ( injected ) {
data . anyMatchFilter = query . join ( ' && ' ) ;
}
2015-03-28 20:03:50 +00:00
}
}
2015-07-23 04:29:51 +00:00
// optimize searching only through already filtered rows - see #313
searchFiltered = wo . filter _searchFiltered ;
lastSearch = c . lastSearch || c . $table . data ( 'lastSearch' ) || [ ] ;
if ( searchFiltered ) {
// cycle through all filters; include last ( columnIndex + 1 = match any column ). Fixes #669
for ( indx = 0 ; indx < columnIndex + 1 ; indx ++ ) {
val = filters [ indx ] || '' ;
// break out of loop if we've already determined not to search filtered rows
if ( ! searchFiltered ) { indx = columnIndex ; }
// search already filtered rows if...
searchFiltered = searchFiltered && lastSearch . length &&
// there are no changes from beginning of filter
val . indexOf ( lastSearch [ indx ] || '' ) === 0 &&
// if there is NOT a logical 'or', or range ( 'to' or '-' ) in the string
2015-11-10 21:27:30 +00:00
! tsfRegex . alreadyFiltered . test ( val ) &&
2015-07-23 04:29:51 +00:00
// if we are not doing exact matches, using '|' ( logical or ) or not '!'
2015-11-10 21:27:30 +00:00
! tsfRegex . exactTest . test ( val ) &&
2015-07-23 04:29:51 +00:00
// don't search only filtered if the value is negative
// ( '> -10' => '> -100' will ignore hidden rows )
2015-11-10 21:27:30 +00:00
! ( tsfRegex . isNeg1 . test ( val ) || tsfRegex . isNeg2 . test ( val ) ) &&
2015-07-23 04:29:51 +00:00
// if filtering using a select without a 'filter-match' class ( exact match ) - fixes #593
2015-10-18 18:21:11 +00:00
! ( val !== '' && c . $filters && c . $filters . filter ( '[data-column="' + indx + '"]' ) . find ( 'select' ) . length &&
2016-03-02 05:00:22 +00:00
! tsf . matchType ( c , indx ) ) ;
2015-07-23 04:29:51 +00:00
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
notFiltered = $rows . not ( '.' + wo . filter _filteredRow ) . length ;
// can't search when all rows are hidden - this happens when looking for exact matches
if ( searchFiltered && notFiltered === 0 ) { searchFiltered = false ; }
2018-03-18 13:49:07 +00:00
if ( debug ) {
console . log ( 'Filter >> Searching through ' +
2015-07-23 04:29:51 +00:00
( searchFiltered && notFiltered < len ? notFiltered : 'all' ) + ' rows' ) ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
if ( data . anyMatchFlag ) {
if ( c . sortLocaleCompare ) {
// replace accents
data . anyMatchFilter = ts . replaceAccents ( data . anyMatchFilter ) ;
}
2015-11-10 21:27:30 +00:00
if ( wo . filter _defaultFilter && tsfRegex . iQuery . test ( vars . defaultAnyFilter ) ) {
2015-08-23 18:22:56 +00:00
data . anyMatchFilter = tsf . defaultFilter ( data . anyMatchFilter , vars . defaultAnyFilter ) ;
2015-07-23 04:29:51 +00:00
// clear search filtered flag because default filters are not saved to the last search
searchFiltered = false ;
}
// make iAnyMatchFilter lowercase unless both filter widget & core ignoreCase options are true
// when c.ignoreCase is true, the cache contains all lower case data
data . iAnyMatchFilter = ! ( wo . filter _ignoreCase && c . ignoreCase ) ?
data . anyMatchFilter :
data . anyMatchFilter . toLowerCase ( ) ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
// loop through the rows
for ( rowIndex = 0 ; rowIndex < len ; rowIndex ++ ) {
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
txt = $rows [ rowIndex ] . className ;
// the first row can never be a child row
2015-11-10 21:27:30 +00:00
isChild = rowIndex && tsfRegex . child . test ( txt ) ;
2015-07-23 04:29:51 +00:00
// skip child rows & already filtered rows
2015-11-10 21:27:30 +00:00
if ( isChild || ( searchFiltered && tsfRegex . filtered . test ( txt ) ) ) {
2015-07-23 04:29:51 +00:00
continue ;
2015-05-17 20:32:53 +00:00
}
2015-07-23 04:29:51 +00:00
data . $row = $rows . eq ( rowIndex ) ;
2016-08-01 01:48:27 +00:00
data . rowIndex = rowIndex ;
2015-07-23 04:29:51 +00:00
data . cacheArray = norm _rows [ rowIndex ] ;
rowData = data . cacheArray [ c . columns ] ;
data . rawArray = rowData . raw ;
data . childRowText = '' ;
if ( ! wo . filter _childByColumn ) {
txt = '' ;
// child row cached text
childRow = rowData . child ;
// so, if 'table.config.widgetOptions.filter_childRows' is true and there is
// a match anywhere in the child row, then it will make the row visible
// checked here so the option can be changed dynamically
2015-05-17 20:32:53 +00:00
for ( indx = 0 ; indx < childRow . length ; indx ++ ) {
2015-09-24 13:49:17 +00:00
txt += ' ' + childRow [ indx ] . join ( ' ' ) || '' ;
2015-04-08 03:12:53 +00:00
}
2015-07-23 04:29:51 +00:00
data . childRowText = wo . filter _childRows ?
( wo . filter _ignoreCase ? txt . toLowerCase ( ) : txt ) :
'' ;
}
2015-09-23 12:20:32 +00:00
showRow = false ;
2015-09-24 03:46:03 +00:00
showParent = tsf . processRow ( c , data , vars ) ;
2015-09-24 13:49:17 +00:00
$row = rowData . $row ;
2015-09-24 03:46:03 +00:00
// don't pass reference to val
val = showParent ? true : false ;
2016-01-11 04:22:16 +00:00
childRow = rowData . $row . filter ( ':gt(0)' ) ;
2015-07-23 04:29:51 +00:00
if ( wo . filter _childRows && childRow . length ) {
if ( wo . filter _childByColumn ) {
2015-09-24 13:49:17 +00:00
if ( ! wo . filter _childWithSibs ) {
// hide all child rows
childRow . addClass ( wo . filter _filteredRow ) ;
// if only showing resulting child row, only include parent
$row = $row . eq ( 0 ) ;
}
2015-07-23 04:29:51 +00:00
// cycle through each child row
for ( indx = 0 ; indx < childRow . length ; indx ++ ) {
data . $row = childRow . eq ( indx ) ;
data . cacheArray = rowData . child [ indx ] ;
data . rawArray = data . cacheArray ;
2015-09-23 12:20:32 +00:00
val = tsf . processRow ( c , data , vars ) ;
2015-07-23 04:29:51 +00:00
// use OR comparison on child rows
2015-09-23 12:20:32 +00:00
showRow = showRow || val ;
if ( ! wo . filter _childWithSibs && val ) {
childRow . eq ( indx ) . removeClass ( wo . filter _filteredRow ) ;
}
2015-07-23 04:29:51 +00:00
}
}
2015-09-24 03:46:03 +00:00
// keep parent row match even if no child matches... see #1020
showRow = showRow || showParent ;
2015-09-23 12:20:32 +00:00
} else {
showRow = val ;
2015-03-28 20:03:50 +00:00
}
2015-09-23 12:20:32 +00:00
$row
2015-07-23 04:29:51 +00:00
. toggleClass ( wo . filter _filteredRow , ! showRow ) [ 0 ]
. display = showRow ? '' : 'none' ;
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
c . filteredRows += $rows . not ( '.' + wo . filter _filteredRow ) . length ;
c . totalRows += $rows . length ;
ts . processTbody ( table , $tbody , false ) ;
}
2017-04-02 11:33:20 +00:00
// lastCombinedFilter is no longer used internally
c . lastCombinedFilter = storedFilters . join ( '' ) ; // save last search
2015-07-23 04:29:51 +00:00
// don't save 'filters' directly since it may have altered ( AnyMatch column searches )
c . lastSearch = storedFilters ;
c . $table . data ( 'lastSearch' , storedFilters ) ;
if ( wo . filter _saveFilters && ts . storage ) {
2015-10-18 18:21:11 +00:00
ts . storage ( table , 'tablesorter-filters' , tsf . processFilters ( storedFilters , true ) ) ;
2015-07-23 04:29:51 +00:00
}
2018-03-18 13:49:07 +00:00
if ( debug ) {
console . log ( 'Filter >> Completed search' + ts . benchmark ( time ) ) ;
2015-07-23 04:29:51 +00:00
}
if ( wo . filter _initialized ) {
2015-12-13 22:24:42 +00:00
c . $table . triggerHandler ( 'filterBeforeEnd' , c ) ;
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'filterEnd' , c ) ;
2015-07-23 04:29:51 +00:00
}
setTimeout ( function ( ) {
2015-10-22 21:41:34 +00:00
ts . applyWidget ( c . table ) ; // make sure zebra widget is applied
2015-07-23 04:29:51 +00:00
} , 0 ) ;
} ,
getOptionSource : function ( table , column , onlyAvail ) {
table = $ ( table ) [ 0 ] ;
2015-09-07 20:47:16 +00:00
var c = table . config ,
2015-07-23 04:29:51 +00:00
wo = c . widgetOptions ,
arry = false ,
source = wo . filter _selectSource ,
last = c . $table . data ( 'lastSearch' ) || [ ] ,
2015-09-07 20:47:16 +00:00
fxn = typeof source === 'function' ? true : ts . getColumnData ( table , source , column ) ;
2015-07-23 04:29:51 +00:00
if ( onlyAvail && last [ column ] !== '' ) {
onlyAvail = false ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
// filter select source option
if ( fxn === true ) {
// OVERALL source
arry = source ( table , column , onlyAvail ) ;
} else if ( fxn instanceof $ || ( $ . type ( fxn ) === 'string' && fxn . indexOf ( '</option>' ) >= 0 ) ) {
// selectSource is a jQuery object or string of options
return fxn ;
} else if ( $ . isArray ( fxn ) ) {
arry = fxn ;
} else if ( $ . type ( source ) === 'object' && fxn ) {
// custom select source function for a SPECIFIC COLUMN
arry = fxn ( table , column , onlyAvail ) ;
2017-05-26 20:11:58 +00:00
// abort - updating the selects from an external method
if ( arry === null ) {
return null ;
}
2015-07-23 04:29:51 +00:00
}
if ( arry === false ) {
// fall back to original method
2015-08-23 18:22:56 +00:00
arry = tsf . getOptions ( table , column , onlyAvail ) ;
2015-07-23 04:29:51 +00:00
}
2015-03-28 20:03:50 +00:00
2015-09-07 20:47:16 +00:00
return tsf . processOptions ( table , column , arry ) ;
} ,
processOptions : function ( table , column , arry ) {
if ( ! $ . isArray ( arry ) ) {
return false ;
}
table = $ ( table ) [ 0 ] ;
2015-11-10 21:27:30 +00:00
var cts , txt , indx , len , parsedTxt , str ,
2015-09-07 20:47:16 +00:00
c = table . config ,
validColumn = typeof column !== 'undefined' && column !== null && column >= 0 && column < c . columns ,
2016-09-23 16:45:10 +00:00
direction = validColumn ? c . $headerIndexed [ column ] . hasClass ( 'filter-select-sort-desc' ) : false ,
2015-09-07 20:47:16 +00:00
parsed = [ ] ;
2015-07-23 04:29:51 +00:00
// get unique elements and sort the list
// if $.tablesorter.sortText exists ( not in the original tablesorter ),
// then natural sort the list otherwise use a basic sort
arry = $ . grep ( arry , function ( value , indx ) {
2015-11-10 21:27:30 +00:00
if ( value . text ) {
return true ;
}
2015-07-23 04:29:51 +00:00
return $ . inArray ( value , arry ) === indx ;
} ) ;
2015-09-07 20:47:16 +00:00
if ( validColumn && c . $headerIndexed [ column ] . hasClass ( 'filter-select-nosort' ) ) {
2015-07-23 04:29:51 +00:00
// unsorted select options
return arry ;
} else {
len = arry . length ;
// parse select option values
for ( indx = 0 ; indx < len ; indx ++ ) {
txt = arry [ indx ] ;
2015-11-10 21:27:30 +00:00
// check for object
str = txt . text ? txt . text : txt ;
// sortNatural breaks if you don't pass it strings
parsedTxt = ( validColumn && c . parsers && c . parsers . length &&
c . parsers [ column ] . format ( str , table , [ ] , column ) || str ) . toString ( ) ;
parsedTxt = c . widgetOptions . filter _ignoreCase ? parsedTxt . toLowerCase ( ) : parsedTxt ;
2015-07-23 04:29:51 +00:00
// parse array data using set column parser; this DOES NOT pass the original
// table cell to the parser format function
2015-11-10 21:27:30 +00:00
if ( txt . text ) {
txt . parsed = parsedTxt ;
2016-03-02 05:00:22 +00:00
parsed [ parsed . length ] = txt ;
2015-11-10 21:27:30 +00:00
} else {
2016-03-02 05:00:22 +00:00
parsed [ parsed . length ] = {
2015-11-10 21:27:30 +00:00
text : txt ,
// check parser length - fixes #934
parsed : parsedTxt
2016-03-02 05:00:22 +00:00
} ;
2015-11-10 21:27:30 +00:00
}
2015-07-23 04:29:51 +00:00
}
// sort parsed select options
cts = c . textSorter || '' ;
parsed . sort ( function ( a , b ) {
2016-09-23 16:45:10 +00:00
var x = direction ? b . parsed : a . parsed ,
y = direction ? a . parsed : b . parsed ;
2015-09-07 20:47:16 +00:00
if ( validColumn && typeof cts === 'function' ) {
2015-07-23 04:29:51 +00:00
// custom OVERALL text sorter
return cts ( x , y , true , column , table ) ;
2015-09-07 20:47:16 +00:00
} else if ( validColumn && typeof cts === 'object' && cts . hasOwnProperty ( column ) ) {
2015-07-23 04:29:51 +00:00
// custom text sorter for a SPECIFIC COLUMN
return cts [ column ] ( x , y , true , column , table ) ;
} else if ( ts . sortNatural ) {
// fall back to natural sort
return ts . sortNatural ( x , y ) ;
}
// using an older version! do a basic sort
return true ;
2015-05-17 20:32:53 +00:00
} ) ;
2015-07-23 04:29:51 +00:00
// rebuild arry from sorted parsed data
arry = [ ] ;
len = parsed . length ;
for ( indx = 0 ; indx < len ; indx ++ ) {
2016-03-02 05:00:22 +00:00
arry [ arry . length ] = parsed [ indx ] ;
2015-07-23 04:29:51 +00:00
}
return arry ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ,
getOptions : function ( table , column , onlyAvail ) {
table = $ ( table ) [ 0 ] ;
2015-10-04 14:26:07 +00:00
var rowIndex , tbodyIndex , len , row , cache , indx , child , childLen ,
2015-07-23 04:29:51 +00:00
c = table . config ,
wo = c . widgetOptions ,
arry = [ ] ;
for ( tbodyIndex = 0 ; tbodyIndex < c . $tbodies . length ; tbodyIndex ++ ) {
cache = c . cache [ tbodyIndex ] ;
len = c . cache [ tbodyIndex ] . normalized . length ;
// loop through the rows
for ( rowIndex = 0 ; rowIndex < len ; rowIndex ++ ) {
// get cached row from cache.row ( old ) or row data object
// ( new; last item in normalized array )
row = cache . row ?
cache . row [ rowIndex ] :
cache . normalized [ rowIndex ] [ c . columns ] . $row [ 0 ] ;
// check if has class filtered
if ( onlyAvail && row . className . match ( wo . filter _filteredRow ) ) {
continue ;
}
// get non-normalized cell content
if ( wo . filter _useParsedData ||
c . parsers [ column ] . parsed ||
c . $headerIndexed [ column ] . hasClass ( 'filter-parsed' ) ) {
2016-03-02 05:00:22 +00:00
arry [ arry . length ] = '' + cache . normalized [ rowIndex ] [ column ] ;
2015-10-04 14:26:07 +00:00
// child row parsed data
if ( wo . filter _childRows && wo . filter _childByColumn ) {
childLen = cache . normalized [ rowIndex ] [ c . columns ] . $row . length - 1 ;
for ( indx = 0 ; indx < childLen ; indx ++ ) {
2016-03-02 05:00:22 +00:00
arry [ arry . length ] = '' + cache . normalized [ rowIndex ] [ c . columns ] . child [ indx ] [ column ] ;
2015-10-04 14:26:07 +00:00
}
}
2015-07-23 04:29:51 +00:00
} else {
// get raw cached data instead of content directly from the cells
2016-03-02 05:00:22 +00:00
arry [ arry . length ] = cache . normalized [ rowIndex ] [ c . columns ] . raw [ column ] ;
2015-10-04 14:26:07 +00:00
// child row unparsed data
if ( wo . filter _childRows && wo . filter _childByColumn ) {
childLen = cache . normalized [ rowIndex ] [ c . columns ] . $row . length ;
for ( indx = 1 ; indx < childLen ; indx ++ ) {
child = cache . normalized [ rowIndex ] [ c . columns ] . $row . eq ( indx ) . children ( ) . eq ( column ) ;
2016-03-02 05:00:22 +00:00
arry [ arry . length ] = '' + ts . getElementText ( c , child , column ) ;
2015-10-04 14:26:07 +00:00
}
}
2015-07-23 04:29:51 +00:00
}
}
2015-03-28 20:03:50 +00:00
}
return arry ;
2015-07-23 04:29:51 +00:00
} ,
buildSelect : function ( table , column , arry , updating , onlyAvail ) {
table = $ ( table ) [ 0 ] ;
column = parseInt ( column , 10 ) ;
if ( ! table . config . cache || $ . isEmptyObject ( table . config . cache ) ) {
return ;
}
2015-09-07 20:47:16 +00:00
2015-11-10 21:27:30 +00:00
var indx , val , txt , t , $filters , $filter , option ,
2015-07-23 04:29:51 +00:00
c = table . config ,
wo = c . widgetOptions ,
node = c . $headerIndexed [ column ] ,
// t.data( 'placeholder' ) won't work in jQuery older than 1.4.3
options = '<option value="">' +
( node . data ( 'placeholder' ) ||
node . attr ( 'data-placeholder' ) ||
wo . filter _placeholder . select || ''
) + '</option>' ,
// Get curent filter value
currentValue = c . $table
. find ( 'thead' )
. find ( 'select.' + tscss . filter + '[data-column="' + column + '"]' )
. val ( ) ;
2015-09-07 20:47:16 +00:00
2015-07-23 04:29:51 +00:00
// nothing included in arry ( external source ), so get the options from
// filter_selectSource or column data
if ( typeof arry === 'undefined' || arry === '' ) {
2015-08-23 18:22:56 +00:00
arry = tsf . getOptionSource ( table , column , onlyAvail ) ;
2017-05-26 20:11:58 +00:00
// abort, selects are updated by an external method
if ( arry === null ) {
return ;
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
if ( $ . isArray ( arry ) ) {
// build option list
for ( indx = 0 ; indx < arry . length ; indx ++ ) {
2015-11-10 21:27:30 +00:00
option = arry [ indx ] ;
if ( option . text ) {
// OBJECT!! add data-function-name in case the value is set in filter_functions
option [ 'data-function-name' ] = typeof option . value === 'undefined' ? option . text : option . value ;
// support jQuery < v1.8, otherwise the below code could be shortened to
// options += $( '<option>', option )[ 0 ].outerHTML;
options += '<option' ;
for ( val in option ) {
if ( option . hasOwnProperty ( val ) && val !== 'text' ) {
2018-03-18 13:49:07 +00:00
options += ' ' + val + '="' + option [ val ] . replace ( tsfRegex . quote , '"' ) + '"' ;
2015-11-10 21:27:30 +00:00
}
}
if ( ! option . value ) {
2018-03-18 13:49:07 +00:00
options += ' value="' + option . text . replace ( tsfRegex . quote , '"' ) + '"' ;
2015-11-10 21:27:30 +00:00
}
2018-03-18 13:49:07 +00:00
options += '>' + option . text . replace ( tsfRegex . quote , '"' ) + '</option>' ;
2015-11-10 21:27:30 +00:00
// above code is needed in jQuery < v1.8
// make sure we don't turn an object into a string (objects without a "text" property)
} else if ( '' + option !== '[object Object]' ) {
txt = option = ( '' + option ) . replace ( tsfRegex . quote , '"' ) ;
val = txt ;
// allow including a symbol in the selectSource array
// 'a-z|A through Z' so that 'a-z' becomes the option value
// and 'A through Z' becomes the option text
if ( txt . indexOf ( wo . filter _selectSourceSeparator ) >= 0 ) {
t = txt . split ( wo . filter _selectSourceSeparator ) ;
val = t [ 0 ] ;
txt = t [ 1 ] ;
}
// replace quotes - fixes #242 & ignore empty strings
// see http://stackoverflow.com/q/14990971/145346
options += option !== '' ?
'<option ' +
( val === txt ? '' : 'data-function-name="' + option + '" ' ) +
'value="' + val + '">' + txt +
'</option>' : '' ;
2015-07-23 04:29:51 +00:00
}
}
// clear arry so it doesn't get appended twice
arry = [ ] ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
// update all selects in the same column ( clone thead in sticky headers &
// any external selects ) - fixes 473
$filters = ( c . $filters ? c . $filters : c . $table . children ( 'thead' ) )
. find ( '.' + tscss . filter ) ;
if ( wo . filter _$externalFilters ) {
$filters = $filters && $filters . length ?
$filters . add ( wo . filter _$externalFilters ) :
wo . filter _$externalFilters ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
$filter = $filters . filter ( 'select[data-column="' + column + '"]' ) ;
// make sure there is a select there!
if ( $filter . length ) {
$filter [ updating ? 'html' : 'append' ] ( options ) ;
if ( ! $ . isArray ( arry ) ) {
// append options if arry is provided externally as a string or jQuery object
// options ( default value ) was already added
$filter . append ( arry ) . val ( currentValue ) ;
}
$filter . val ( currentValue ) ;
}
} ,
buildDefault : function ( table , updating ) {
var columnIndex , $header , noSelect ,
c = table . config ,
wo = c . widgetOptions ,
columns = c . columns ;
// build default select dropdown
for ( columnIndex = 0 ; columnIndex < columns ; columnIndex ++ ) {
$header = c . $headerIndexed [ columnIndex ] ;
noSelect = ! ( $header . hasClass ( 'filter-false' ) || $header . hasClass ( 'parser-false' ) ) ;
// look for the filter-select class; build/update it if found
if ( ( $header . hasClass ( 'filter-select' ) ||
ts . getColumnData ( table , wo . filter _functions , columnIndex ) === true ) && noSelect ) {
2015-08-23 18:22:56 +00:00
tsf . buildSelect ( table , columnIndex , '' , updating , $header . hasClass ( wo . filter _onlyAvail ) ) ;
2015-07-23 04:29:51 +00:00
}
2015-03-28 20:03:50 +00:00
}
}
2015-07-23 04:29:51 +00:00
} ;
2015-11-10 21:27:30 +00:00
// filter regex variable
tsfRegex = tsf . regex ;
2015-07-23 04:29:51 +00:00
ts . getFilters = function ( table , getRaw , setFilters , skipFirst ) {
var i , $filters , $column , cols ,
2016-08-01 01:48:27 +00:00
filters = [ ] ,
2015-07-23 04:29:51 +00:00
c = table ? $ ( table ) [ 0 ] . config : '' ,
wo = c ? c . widgetOptions : '' ;
if ( ( getRaw !== true && wo && ! wo . filter _columnFilters ) ||
// setFilters called, but last search is exactly the same as the current
// fixes issue #733 & #903 where calling update causes the input values to reset
2017-04-19 00:50:08 +00:00
( $ . isArray ( setFilters ) && tsf . equalFilters ( c , setFilters , c . lastSearch ) )
) {
2017-04-04 10:16:26 +00:00
return $ ( table ) . data ( 'lastSearch' ) || [ ] ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
if ( c ) {
if ( c . $filters ) {
$filters = c . $filters . find ( '.' + tscss . filter ) ;
}
if ( wo . filter _$externalFilters ) {
$filters = $filters && $filters . length ?
$filters . add ( wo . filter _$externalFilters ) :
wo . filter _$externalFilters ;
}
if ( $filters && $filters . length ) {
filters = setFilters || [ ] ;
for ( i = 0 ; i < c . columns + 1 ; i ++ ) {
cols = ( i === c . columns ?
// 'all' columns can now include a range or set of columms ( data-column='0-2,4,6-7' )
wo . filter _anyColumnSelector + ',' + wo . filter _multipleColumnSelector :
'[data-column="' + i + '"]' ) ;
$column = $filters . filter ( cols ) ;
if ( $column . length ) {
// move the latest search to the first slot in the array
2015-08-23 18:22:56 +00:00
$column = tsf . getLatestSearch ( $column ) ;
2015-07-23 04:29:51 +00:00
if ( $ . isArray ( setFilters ) ) {
// skip first ( latest input ) to maintain cursor position while typing
if ( skipFirst && $column . length > 1 ) {
$column = $column . slice ( 1 ) ;
}
if ( i === c . columns ) {
// prevent data-column='all' from filling data-column='0,1' ( etc )
cols = $column . filter ( wo . filter _anyColumnSelector ) ;
$column = cols . length ? cols : $column ;
}
2015-05-17 20:32:53 +00:00
$column
2015-07-23 04:29:51 +00:00
. val ( setFilters [ i ] )
2015-08-27 12:13:46 +00:00
// must include a namespace here; but not c.namespace + 'filter'?
. trigger ( 'change' + c . namespace ) ;
2015-03-28 20:03:50 +00:00
} else {
2015-07-23 04:29:51 +00:00
filters [ i ] = $column . val ( ) || '' ;
// don't change the first... it will move the cursor
if ( i === c . columns ) {
// don't update range columns from 'all' setting
$column
. slice ( 1 )
. filter ( '[data-column*="' + $column . attr ( 'data-column' ) + '"]' )
. val ( filters [ i ] ) ;
} else {
$column
. slice ( 1 )
. val ( filters [ i ] ) ;
}
}
// save any match input dynamically
if ( i === c . columns && $column . length ) {
wo . filter _$anyMatch = $column ;
2015-03-28 20:03:50 +00:00
}
}
}
}
}
2015-07-23 04:29:51 +00:00
return filters ;
} ;
ts . setFilters = function ( table , filter , apply , skipFirst ) {
var c = table ? $ ( table ) [ 0 ] . config : '' ,
valid = ts . getFilters ( table , true , filter , skipFirst ) ;
2015-11-05 02:15:37 +00:00
// default apply to "true"
if ( typeof apply === 'undefined' ) {
apply = true ;
}
2015-07-23 04:29:51 +00:00
if ( c && apply ) {
// ensure new set filters are applied, even if the search is the same
c . lastCombinedFilter = null ;
c . lastSearch = [ ] ;
2015-08-23 18:22:56 +00:00
tsf . searching ( c . table , filter , skipFirst ) ;
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'filterFomatterUpdate' ) ;
2015-07-23 04:29:51 +00:00
}
2016-08-01 01:48:27 +00:00
return valid . length !== 0 ;
2015-07-23 04:29:51 +00:00
} ;
2015-03-28 20:03:50 +00:00
2015-05-17 20:32:53 +00:00
} ) ( jQuery ) ;
2015-03-28 20:03:50 +00:00
2017-09-28 02:07:28 +00:00
/*! Widget: stickyHeaders - updated 9/27/2017 (v2.29.0) */ / *
2015-03-28 20:03:50 +00:00
* Requires tablesorter v2 . 8 + and jQuery 1.4 . 3 +
* by Rob Garrison
* /
; ( function ( $ , window ) {
2015-07-23 04:29:51 +00:00
'use strict' ;
var ts = $ . tablesorter || { } ;
$ . extend ( ts . css , {
sticky : 'tablesorter-stickyHeader' , // stickyHeader
stickyVis : 'tablesorter-sticky-visible' ,
stickyHide : 'tablesorter-sticky-hidden' ,
stickyWrap : 'tablesorter-sticky-wrapper'
} ) ;
// Add a resize event to table headers
ts . addHeaderResizeEvent = function ( table , disable , settings ) {
table = $ ( table ) [ 0 ] ; // make sure we're using a dom element
if ( ! table . config ) { return ; }
var defaults = {
timer : 250
} ,
options = $ . extend ( { } , defaults , settings ) ,
c = table . config ,
wo = c . widgetOptions ,
checkSizes = function ( triggerEvent ) {
var index , headers , $header , sizes , width , height ,
len = c . $headers . length ;
wo . resize _flag = true ;
headers = [ ] ;
for ( index = 0 ; index < len ; index ++ ) {
$header = c . $headers . eq ( index ) ;
sizes = $header . data ( 'savedSizes' ) || [ 0 , 0 ] ; // fixes #394
width = $header [ 0 ] . offsetWidth ;
height = $header [ 0 ] . offsetHeight ;
if ( width !== sizes [ 0 ] || height !== sizes [ 1 ] ) {
$header . data ( 'savedSizes' , [ width , height ] ) ;
headers . push ( $header [ 0 ] ) ;
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
if ( headers . length && triggerEvent !== false ) {
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'resize' , [ headers ] ) ;
2015-07-23 04:29:51 +00:00
}
wo . resize _flag = false ;
} ;
clearInterval ( wo . resize _timer ) ;
if ( disable ) {
2015-03-28 20:03:50 +00:00
wo . resize _flag = false ;
2015-07-23 04:29:51 +00:00
return false ;
2015-03-28 20:03:50 +00:00
}
2016-03-02 05:00:22 +00:00
checkSizes ( false ) ;
2015-07-23 04:29:51 +00:00
wo . resize _timer = setInterval ( function ( ) {
if ( wo . resize _flag ) { return ; }
checkSizes ( ) ;
} , options . timer ) ;
} ;
2017-06-02 22:49:41 +00:00
function getStickyOffset ( c , wo ) {
var $el = isNaN ( wo . stickyHeaders _offset ) ? $ ( wo . stickyHeaders _offset ) : [ ] ;
return $el . length ?
$el . height ( ) || 0 :
parseInt ( wo . stickyHeaders _offset , 10 ) || 0 ;
}
2015-07-23 04:29:51 +00:00
// Sticky headers based on this awesome article:
// http://css-tricks.com/13465-persistent-headers/
// and https://github.com/jmosbech/StickyTableHeaders by Jonas Mosbech
// **************************
ts . addWidget ( {
id : 'stickyHeaders' ,
2017-01-07 02:56:05 +00:00
priority : 54 , // sticky widget must be initialized after the filter & before pager widget!
2015-07-23 04:29:51 +00:00
options : {
stickyHeaders : '' , // extra class name added to the sticky header row
2016-08-01 01:48:27 +00:00
stickyHeaders _appendTo : null , // jQuery selector or object to phycially attach the sticky headers
stickyHeaders _attachTo : null , // jQuery selector or object to attach scroll listener to (overridden by xScroll & yScroll settings)
2015-07-23 04:29:51 +00:00
stickyHeaders _xScroll : null , // jQuery selector or object to monitor horizontal scroll position (defaults: xScroll > attachTo > window)
stickyHeaders _yScroll : null , // jQuery selector or object to monitor vertical scroll position (defaults: yScroll > attachTo > window)
stickyHeaders _offset : 0 , // number or jquery selector targeting the position:fixed element
stickyHeaders _filteredToTop : true , // scroll table top into view after filtering
stickyHeaders _cloneId : '-sticky' , // added to table ID, if it exists
stickyHeaders _addResizeEvent : true , // trigger 'resize' event on headers
stickyHeaders _includeCaption : true , // if false and a caption exist, it won't be included in the sticky header
stickyHeaders _zIndex : 2 // The zIndex of the stickyHeaders, allows the user to adjust this to their needs
} ,
format : function ( table , c , wo ) {
// filter widget doesn't initialize on an empty table. Fixes #449
if ( c . $table . hasClass ( 'hasStickyHeaders' ) || ( $ . inArray ( 'filter' , c . widgets ) >= 0 && ! c . $table . hasClass ( 'hasFilters' ) ) ) {
return ;
}
var index , len , $t ,
$table = c . $table ,
// add position: relative to attach element, hopefully it won't cause trouble.
2018-02-25 19:04:11 +00:00
$attach = $ ( wo . stickyHeaders _attachTo || wo . stickyHeaders _appendTo ) ,
2015-07-23 04:29:51 +00:00
namespace = c . namespace + 'stickyheaders ' ,
// element to watch for the scroll event
$yScroll = $ ( wo . stickyHeaders _yScroll || wo . stickyHeaders _attachTo || window ) ,
$xScroll = $ ( wo . stickyHeaders _xScroll || wo . stickyHeaders _attachTo || window ) ,
$thead = $table . children ( 'thead:first' ) ,
$header = $thead . children ( 'tr' ) . not ( '.sticky-false' ) . children ( ) ,
$tfoot = $table . children ( 'tfoot' ) ,
2017-06-02 22:49:41 +00:00
stickyOffset = getStickyOffset ( c , wo ) ,
2015-07-23 04:29:51 +00:00
// is this table nested? If so, find parent sticky header wrapper (div, not table)
$nestedSticky = $table . parent ( ) . closest ( '.' + ts . css . table ) . hasClass ( 'hasStickyHeaders' ) ?
$table . parent ( ) . closest ( 'table.tablesorter' ) [ 0 ] . config . widgetOptions . $sticky . parent ( ) : [ ] ,
nestedStickyTop = $nestedSticky . length ? $nestedSticky . height ( ) : 0 ,
// clone table, then wrap to make sticky header
$stickyTable = wo . $sticky = $table . clone ( )
. addClass ( 'containsStickyHeaders ' + ts . css . sticky + ' ' + wo . stickyHeaders + ' ' + c . namespace . slice ( 1 ) + '_extra_table' )
. wrap ( '<div class="' + ts . css . stickyWrap + '">' ) ,
$stickyWrap = $stickyTable . parent ( )
. addClass ( ts . css . stickyHide )
. css ( {
position : $attach . length ? 'absolute' : 'fixed' ,
padding : parseInt ( $stickyTable . parent ( ) . parent ( ) . css ( 'padding-left' ) , 10 ) ,
top : stickyOffset + nestedStickyTop ,
left : 0 ,
visibility : 'hidden' ,
zIndex : wo . stickyHeaders _zIndex || 2
} ) ,
$stickyThead = $stickyTable . children ( 'thead:first' ) ,
$stickyCells ,
laststate = '' ,
2018-03-18 13:49:07 +00:00
setWidth = function ( $orig , $clone ) {
2015-07-23 04:29:51 +00:00
var index , width , border , $cell , $this ,
$cells = $orig . filter ( ':visible' ) ,
len = $cells . length ;
for ( index = 0 ; index < len ; index ++ ) {
$cell = $clone . filter ( ':visible' ) . eq ( index ) ;
$this = $cells . eq ( index ) ;
// code from https://github.com/jmosbech/StickyTableHeaders
if ( $this . css ( 'box-sizing' ) === 'border-box' ) {
width = $this . outerWidth ( ) ;
} else {
if ( $cell . css ( 'border-collapse' ) === 'collapse' ) {
if ( window . getComputedStyle ) {
width = parseFloat ( window . getComputedStyle ( $this [ 0 ] , null ) . width ) ;
} else {
// ie8 only
border = parseFloat ( $this . css ( 'border-width' ) ) ;
width = $this . outerWidth ( ) - parseFloat ( $this . css ( 'padding-left' ) ) - parseFloat ( $this . css ( 'padding-right' ) ) - border ;
}
2015-03-28 20:03:50 +00:00
} else {
2015-07-23 04:29:51 +00:00
width = $this . width ( ) ;
2015-03-28 20:03:50 +00:00
}
}
2015-07-23 04:29:51 +00:00
$cell . css ( {
'width' : width ,
'min-width' : width ,
'max-width' : width
} ) ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ,
2018-02-25 19:04:11 +00:00
getLeftPosition = function ( yWindow ) {
if ( yWindow === false && $nestedSticky . length ) {
return $table . position ( ) . left ;
}
2017-09-28 02:07:28 +00:00
return $attach . length ?
parseInt ( $attach . css ( 'padding-left' ) , 10 ) || 0 :
$table . offset ( ) . left - parseInt ( $table . css ( 'margin-left' ) , 10 ) - $ ( window ) . scrollLeft ( ) ;
} ,
2015-07-23 04:29:51 +00:00
resizeHeader = function ( ) {
$stickyWrap . css ( {
2017-09-28 02:07:28 +00:00
left : getLeftPosition ( ) ,
2015-07-23 04:29:51 +00:00
width : $table . outerWidth ( )
2015-03-28 20:03:50 +00:00
} ) ;
2015-07-23 04:29:51 +00:00
setWidth ( $table , $stickyTable ) ;
setWidth ( $header , $stickyCells ) ;
} ,
scrollSticky = function ( resizing ) {
if ( ! $table . is ( ':visible' ) ) { return ; } // fixes #278
// Detect nested tables - fixes #724
nestedStickyTop = $nestedSticky . length ? $nestedSticky . offset ( ) . top - $yScroll . scrollTop ( ) + $nestedSticky . height ( ) : 0 ;
2017-09-28 02:07:28 +00:00
var tmp ,
offset = $table . offset ( ) ,
2017-06-02 22:49:41 +00:00
stickyOffset = getStickyOffset ( c , wo ) ,
2015-07-23 04:29:51 +00:00
yWindow = $ . isWindow ( $yScroll [ 0 ] ) , // $.isWindow needs jQuery 1.4.3
2018-02-25 19:04:11 +00:00
yScroll = yWindow ?
$yScroll . scrollTop ( ) :
// use parent sticky position if nested AND inside of a scrollable element - see #1512
$nestedSticky . length ? parseInt ( $nestedSticky [ 0 ] . style . top , 10 ) : $yScroll . offset ( ) . top ,
attachTop = $attach . length ? yScroll : $yScroll . scrollTop ( ) ,
2016-05-01 20:33:35 +00:00
captionHeight = wo . stickyHeaders _includeCaption ? 0 : $table . children ( 'caption' ) . height ( ) || 0 ,
scrollTop = attachTop + stickyOffset + nestedStickyTop - captionHeight ,
tableHeight = $table . height ( ) - ( $stickyWrap . height ( ) + ( $tfoot . height ( ) || 0 ) ) - captionHeight ,
2015-07-23 04:29:51 +00:00
isVisible = ( scrollTop > offset . top ) && ( scrollTop < offset . top + tableHeight ) ? 'visible' : 'hidden' ,
2017-09-28 02:07:28 +00:00
state = isVisible === 'visible' ? ts . css . stickyVis : ts . css . stickyHide ,
needsUpdating = ! $stickyWrap . hasClass ( state ) ,
2015-07-23 04:29:51 +00:00
cssSettings = { visibility : isVisible } ;
if ( $attach . length ) {
2017-09-28 02:07:28 +00:00
// attached sticky headers always need updating
needsUpdating = true ;
2015-07-23 04:29:51 +00:00
cssSettings . top = yWindow ? scrollTop - $attach . offset ( ) . top : $attach . scrollTop ( ) ;
}
2017-09-28 02:07:28 +00:00
// adjust when scrolling horizontally - fixes issue #143
2018-02-25 19:04:11 +00:00
tmp = getLeftPosition ( yWindow ) ;
2017-09-28 02:07:28 +00:00
if ( tmp !== parseInt ( $stickyWrap . css ( 'left' ) , 10 ) ) {
needsUpdating = true ;
cssSettings . left = tmp ;
2015-07-23 04:29:51 +00:00
}
2018-02-25 19:04:11 +00:00
cssSettings . top = ( cssSettings . top || 0 ) +
// If nested AND inside of a scrollable element, only add parent sticky height
( ! yWindow && $nestedSticky . length ? $nestedSticky . height ( ) : stickyOffset + nestedStickyTop ) ;
2017-09-28 02:07:28 +00:00
if ( needsUpdating ) {
$stickyWrap
. removeClass ( ts . css . stickyVis + ' ' + ts . css . stickyHide )
. addClass ( state )
. css ( cssSettings ) ;
}
2015-07-23 04:29:51 +00:00
if ( isVisible !== laststate || resizing ) {
// make sure the column widths match
resizeHeader ( ) ;
laststate = isVisible ;
}
} ;
// only add a position relative if a position isn't already defined
if ( $attach . length && ! $attach . css ( 'position' ) ) {
$attach . css ( 'position' , 'relative' ) ;
}
// fix clone ID, if it exists - fixes #271
if ( $stickyTable . attr ( 'id' ) ) { $stickyTable [ 0 ] . id += wo . stickyHeaders _cloneId ; }
// clear out cloned table, except for sticky header
// include caption & filter row (fixes #126 & #249) - don't remove cells to get correct cell indexing
2018-02-25 19:04:11 +00:00
$stickyTable . find ( '> thead:gt(0), tr.sticky-false' ) . hide ( ) ;
$stickyTable . find ( '> tbody, > tfoot' ) . remove ( ) ;
2015-07-23 04:29:51 +00:00
$stickyTable . find ( 'caption' ) . toggle ( wo . stickyHeaders _includeCaption ) ;
// issue #172 - find td/th in sticky header
$stickyCells = $stickyThead . children ( ) . children ( ) ;
$stickyTable . css ( { height : 0 , width : 0 , margin : 0 } ) ;
// remove resizable block
$stickyCells . find ( '.' + ts . css . resizer ) . remove ( ) ;
// update sticky header class names to match real header after sorting
$table
. addClass ( 'hasStickyHeaders' )
. bind ( 'pagerComplete' + namespace , function ( ) {
2015-05-21 23:34:59 +00:00
resizeHeader ( ) ;
2015-07-23 04:29:51 +00:00
} ) ;
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
ts . bindEvents ( table , $stickyThead . children ( ) . children ( '.' + ts . css . header ) ) ;
2015-03-28 20:03:50 +00:00
2016-08-01 01:48:27 +00:00
if ( wo . stickyHeaders _appendTo ) {
$ ( wo . stickyHeaders _appendTo ) . append ( $stickyWrap ) ;
} else {
// add stickyheaders AFTER the table. If the table is selected by ID, the original one (first) will be returned.
$table . after ( $stickyWrap ) ;
}
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
// onRenderHeader is defined, we need to do something about it (fixes #641)
if ( c . onRenderHeader ) {
$t = $stickyThead . children ( 'tr' ) . children ( ) ;
len = $t . length ;
for ( index = 0 ; index < len ; index ++ ) {
// send second parameter
c . onRenderHeader . apply ( $t . eq ( index ) , [ index , c , $stickyTable ] ) ;
}
2015-05-21 23:34:59 +00:00
}
2015-07-23 04:29:51 +00:00
// make it sticky!
$xScroll . add ( $yScroll )
. unbind ( ( 'scroll resize ' . split ( ' ' ) . join ( namespace ) ) . replace ( /\s+/g , ' ' ) )
. bind ( 'scroll resize ' . split ( ' ' ) . join ( namespace ) , function ( event ) {
scrollSticky ( event . type === 'resize' ) ;
} ) ;
c . $table
. unbind ( 'stickyHeadersUpdate' + namespace )
2018-03-18 13:49:07 +00:00
. bind ( 'stickyHeadersUpdate' + namespace , function ( ) {
2015-07-23 04:29:51 +00:00
scrollSticky ( true ) ;
} ) ;
2015-05-21 23:34:59 +00:00
2015-07-23 04:29:51 +00:00
if ( wo . stickyHeaders _addResizeEvent ) {
ts . addHeaderResizeEvent ( table ) ;
}
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
// look for filter widget
if ( $table . hasClass ( 'hasFilters' ) && wo . filter _columnFilters ) {
// scroll table into view after filtering, if sticky header is active - #482
$table . bind ( 'filterEnd' + namespace , function ( ) {
// $(':focus') needs jQuery 1.6+
var $td = $ ( document . activeElement ) . closest ( 'td' ) ,
column = $td . parent ( ) . children ( ) . index ( $td ) ;
// only scroll if sticky header is active
if ( $stickyWrap . hasClass ( ts . css . stickyVis ) && wo . stickyHeaders _filteredToTop ) {
// scroll to original table (not sticky clone)
window . scrollTo ( 0 , $table . position ( ) . top ) ;
// give same input/select focus; check if c.$filters exists; fixes #594
if ( column >= 0 && c . $filters ) {
c . $filters . eq ( column ) . find ( 'a, select, input' ) . filter ( ':visible' ) . focus ( ) ;
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ) ;
ts . filter . bindSearch ( $table , $stickyCells . find ( '.' + ts . css . filter ) ) ;
// support hideFilters
if ( wo . filter _hideFilters ) {
2015-10-18 18:21:11 +00:00
ts . filter . hideFilters ( c , $stickyTable ) ;
2015-03-28 20:03:50 +00:00
}
}
2016-04-01 17:06:10 +00:00
// resize table (Firefox)
if ( wo . stickyHeaders _addResizeEvent ) {
$table . bind ( 'resize' + c . namespace + 'stickyheaders' , function ( ) {
resizeHeader ( ) ;
} ) ;
}
2017-06-02 22:49:41 +00:00
// make sure sticky is visible if page is partially scrolled
scrollSticky ( true ) ;
2015-12-02 01:38:56 +00:00
$table . triggerHandler ( 'stickyHeadersInit' ) ;
2015-07-23 04:29:51 +00:00
} ,
remove : function ( table , c , wo ) {
var namespace = c . namespace + 'stickyheaders ' ;
c . $table
. removeClass ( 'hasStickyHeaders' )
2016-04-01 17:06:10 +00:00
. unbind ( ( 'pagerComplete resize filterEnd stickyHeadersUpdate ' . split ( ' ' ) . join ( namespace ) ) . replace ( /\s+/g , ' ' ) )
2015-07-23 04:29:51 +00:00
. next ( '.' + ts . css . stickyWrap ) . remove ( ) ;
if ( wo . $sticky && wo . $sticky . length ) { wo . $sticky . remove ( ) ; } // remove cloned table
$ ( window )
. add ( wo . stickyHeaders _xScroll )
. add ( wo . stickyHeaders _yScroll )
. add ( wo . stickyHeaders _attachTo )
. unbind ( ( 'scroll resize ' . split ( ' ' ) . join ( namespace ) ) . replace ( /\s+/g , ' ' ) ) ;
2016-03-02 05:00:22 +00:00
ts . addHeaderResizeEvent ( table , true ) ;
2015-07-23 04:29:51 +00:00
}
} ) ;
2015-03-28 20:03:50 +00:00
} ) ( jQuery , window ) ;
2018-02-25 19:04:11 +00:00
/*! Widget: resizable - updated 2018-02-14 (v2.29.6) */
2015-06-27 02:26:44 +00:00
/*jshint browser:true, jquery:true, unused:false */
2015-03-28 20:03:50 +00:00
; ( function ( $ , window ) {
2015-07-23 04:29:51 +00:00
'use strict' ;
var ts = $ . tablesorter || { } ;
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
$ . extend ( ts . css , {
resizableContainer : 'tablesorter-resizable-container' ,
resizableHandle : 'tablesorter-resizable-handle' ,
resizableNoSelect : 'tablesorter-disableSelection' ,
resizableStorage : 'tablesorter-resizable'
} ) ;
// Add extra scroller css
2018-03-18 13:49:07 +00:00
$ ( function ( ) {
2015-07-23 04:29:51 +00:00
var s = '<style>' +
'body.' + ts . css . resizableNoSelect + ' { -ms-user-select: none; -moz-user-select: -moz-none;' +
'-khtml-user-select: none; -webkit-user-select: none; user-select: none; }' +
'.' + ts . css . resizableContainer + ' { position: relative; height: 1px; }' +
// make handle z-index > than stickyHeader z-index, so the handle stays above sticky header
'.' + ts . css . resizableHandle + ' { position: absolute; display: inline-block; width: 8px;' +
'top: 1px; cursor: ew-resize; z-index: 3; user-select: none; -moz-user-select: none; }' +
'</style>' ;
2016-12-15 21:43:33 +00:00
$ ( 'head' ) . append ( s ) ;
2015-07-23 04:29:51 +00:00
} ) ;
ts . resizable = {
init : function ( c , wo ) {
if ( c . $table . hasClass ( 'hasResizable' ) ) { return ; }
c . $table . addClass ( 'hasResizable' ) ;
var noResize , $header , column , storedSizes , tmp ,
$table = c . $table ,
$parent = $table . parent ( ) ,
marginTop = parseInt ( $table . css ( 'margin-top' ) , 10 ) ,
// internal variables
vars = wo . resizable _vars = {
useStorage : ts . storage && wo . resizable !== false ,
$wrap : $parent ,
mouseXPosition : 0 ,
$target : null ,
$next : null ,
overflow : $parent . css ( 'overflow' ) === 'auto' ||
$parent . css ( 'overflow' ) === 'scroll' ||
$parent . css ( 'overflow-x' ) === 'auto' ||
$parent . css ( 'overflow-x' ) === 'scroll' ,
storedSizes : [ ]
} ;
// set default widths
ts . resizableReset ( c . table , true ) ;
// now get measurements!
vars . tableWidth = $table . width ( ) ;
// attempt to autodetect
vars . fullWidth = Math . abs ( $parent . width ( ) - vars . tableWidth ) < 20 ;
/ *
// Hacky method to determine if table width is set to 'auto'
// http://stackoverflow.com/a/20892048/145346
if ( ! vars . fullWidth ) {
tmp = $table . width ( ) ;
$header = $table . wrap ( '<span>' ) . parent ( ) ; // temp variable
storedSizes = parseInt ( $table . css ( 'margin-left' ) , 10 ) || 0 ;
$table . css ( 'margin-left' , storedSizes + 50 ) ;
vars . tableWidth = $header . width ( ) > tmp ? 'auto' : tmp ;
$table . css ( 'margin-left' , storedSizes ? storedSizes : '' ) ;
$header = null ;
$table . unwrap ( '<span>' ) ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
* /
if ( vars . useStorage && vars . overflow ) {
// save table width
ts . storage ( c . table , 'tablesorter-table-original-css-width' , vars . tableWidth ) ;
tmp = ts . storage ( c . table , 'tablesorter-table-resized-width' ) || 'auto' ;
ts . resizable . setWidth ( $table , tmp , true ) ;
}
wo . resizable _vars . storedSizes = storedSizes = ( vars . useStorage ?
ts . storage ( c . table , ts . css . resizableStorage ) :
[ ] ) || [ ] ;
ts . resizable . setWidths ( c , wo , storedSizes ) ;
ts . resizable . updateStoredSizes ( c , wo ) ;
wo . $resizable _container = $ ( '<div class="' + ts . css . resizableContainer + '">' )
. css ( { top : marginTop } )
. insertBefore ( $table ) ;
// add container
2015-03-28 20:03:50 +00:00
for ( column = 0 ; column < c . columns ; column ++ ) {
2015-07-23 04:29:51 +00:00
$header = c . $headerIndexed [ column ] ;
tmp = ts . getColumnData ( c . table , c . headers , column ) ;
noResize = ts . getData ( $header , tmp , 'resizable' ) === 'false' ;
if ( ! noResize ) {
$ ( '<div class="' + ts . css . resizableHandle + '">' )
. appendTo ( wo . $resizable _container )
. attr ( {
'data-column' : column ,
'unselectable' : 'on'
} )
. data ( 'header' , $header )
. bind ( 'selectstart' , false ) ;
2015-03-28 20:03:50 +00:00
}
}
2015-11-05 02:15:37 +00:00
ts . resizable . bindings ( c , wo ) ;
2015-07-23 04:29:51 +00:00
} ,
updateStoredSizes : function ( c , wo ) {
var column , $header ,
len = c . columns ,
vars = wo . resizable _vars ;
vars . storedSizes = [ ] ;
for ( column = 0 ; column < len ; column ++ ) {
$header = c . $headerIndexed [ column ] ;
vars . storedSizes [ column ] = $header . is ( ':visible' ) ? $header . width ( ) : 0 ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ,
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
setWidth : function ( $el , width , overflow ) {
// overflow tables need min & max width set as well
$el . css ( {
'width' : width ,
'min-width' : overflow ? width : '' ,
'max-width' : overflow ? width : ''
} ) ;
} ,
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
setWidths : function ( c , wo , storedSizes ) {
var column , $temp ,
vars = wo . resizable _vars ,
$extra = $ ( c . namespace + '_extra_headers' ) ,
$col = c . $table . children ( 'colgroup' ) . children ( 'col' ) ;
storedSizes = storedSizes || vars . storedSizes || [ ] ;
// process only if table ID or url match
if ( storedSizes . length ) {
for ( column = 0 ; column < c . columns ; column ++ ) {
// set saved resizable widths
ts . resizable . setWidth ( c . $headerIndexed [ column ] , storedSizes [ column ] , vars . overflow ) ;
if ( $extra . length ) {
// stickyHeaders needs to modify min & max width as well
$temp = $extra . eq ( column ) . add ( $col . eq ( column ) ) ;
ts . resizable . setWidth ( $temp , storedSizes [ column ] , vars . overflow ) ;
}
}
$temp = $ ( c . namespace + '_extra_table' ) ;
if ( $temp . length && ! ts . hasWidget ( c . table , 'scroller' ) ) {
ts . resizable . setWidth ( $temp , c . $table . outerWidth ( ) , vars . overflow ) ;
}
}
} ,
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
setHandlePosition : function ( c , wo ) {
var startPosition ,
tableHeight = c . $table . height ( ) ,
$handles = wo . $resizable _container . children ( ) ,
handleCenter = Math . floor ( $handles . width ( ) / 2 ) ;
2016-05-17 00:09:45 +00:00
if ( ts . hasWidget ( c . table , 'scroller' ) ) {
2015-07-23 04:29:51 +00:00
tableHeight = 0 ;
2018-03-18 13:49:07 +00:00
c . $table . closest ( '.' + ts . css . scrollerWrap ) . children ( ) . each ( function ( ) {
2015-07-23 04:29:51 +00:00
var $this = $ ( this ) ;
// center table has a max-height set
tableHeight += $this . filter ( '[style*="height"]' ) . length ? $this . height ( ) : $this . children ( 'table' ) . height ( ) ;
} ) ;
}
2017-04-19 00:50:08 +00:00
if ( ! wo . resizable _includeFooter && c . $table . children ( 'tfoot' ) . length ) {
tableHeight -= c . $table . children ( 'tfoot' ) . height ( ) ;
}
2015-07-23 04:29:51 +00:00
// subtract out table left position from resizable handles. Fixes #864
startPosition = c . $table . position ( ) . left ;
$handles . each ( function ( ) {
var $this = $ ( this ) ,
column = parseInt ( $this . attr ( 'data-column' ) , 10 ) ,
columns = c . columns - 1 ,
$header = $this . data ( 'header' ) ;
if ( ! $header ) { return ; } // see #859
2017-12-13 21:17:20 +00:00
if (
! $header . is ( ':visible' ) ||
( ! wo . resizable _addLastColumn && ts . resizable . checkVisibleColumns ( c , column ) )
) {
2015-07-23 04:29:51 +00:00
$this . hide ( ) ;
} else if ( column < columns || column === columns && wo . resizable _addLastColumn ) {
$this . css ( {
display : 'inline-block' ,
height : tableHeight ,
left : $header . position ( ) . left - startPosition + $header . outerWidth ( ) - handleCenter
} ) ;
}
} ) ;
} ,
2015-03-28 20:03:50 +00:00
2017-12-13 21:17:20 +00:00
// Fixes #1485
checkVisibleColumns : function ( c , column ) {
var i ,
len = 0 ;
for ( i = column + 1 ; i < c . columns ; i ++ ) {
len += c . $headerIndexed [ i ] . is ( ':visible' ) ? 1 : 0 ;
}
return len === 0 ;
} ,
2015-07-23 04:29:51 +00:00
// prevent text selection while dragging resize bar
2015-11-05 02:15:37 +00:00
toggleTextSelection : function ( c , wo , toggle ) {
2015-07-23 04:29:51 +00:00
var namespace = c . namespace + 'tsresize' ;
2015-11-05 02:15:37 +00:00
wo . resizable _vars . disabled = toggle ;
2015-07-23 04:29:51 +00:00
$ ( 'body' ) . toggleClass ( ts . css . resizableNoSelect , toggle ) ;
if ( toggle ) {
$ ( 'body' )
. attr ( 'unselectable' , 'on' )
. bind ( 'selectstart' + namespace , false ) ;
} else {
$ ( 'body' )
. removeAttr ( 'unselectable' )
. unbind ( 'selectstart' + namespace ) ;
}
} ,
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
bindings : function ( c , wo ) {
var namespace = c . namespace + 'tsresize' ;
wo . $resizable _container . children ( ) . bind ( 'mousedown' , function ( event ) {
// save header cell and mouse position
var column ,
vars = wo . resizable _vars ,
$extras = $ ( c . namespace + '_extra_headers' ) ,
$header = $ ( event . target ) . data ( 'header' ) ;
column = parseInt ( $header . attr ( 'data-column' ) , 10 ) ;
vars . $target = $header = $header . add ( $extras . filter ( '[data-column="' + column + '"]' ) ) ;
vars . target = column ;
// if table is not as wide as it's parent, then resize the table
vars . $next = event . shiftKey || wo . resizable _targetLast ?
$header . parent ( ) . children ( ) . not ( '.resizable-false' ) . filter ( ':last' ) :
$header . nextAll ( ':not(.resizable-false)' ) . eq ( 0 ) ;
column = parseInt ( vars . $next . attr ( 'data-column' ) , 10 ) ;
vars . $next = vars . $next . add ( $extras . filter ( '[data-column="' + column + '"]' ) ) ;
vars . next = column ;
vars . mouseXPosition = event . pageX ;
ts . resizable . updateStoredSizes ( c , wo ) ;
2015-11-05 02:15:37 +00:00
ts . resizable . toggleTextSelection ( c , wo , true ) ;
2015-07-23 04:29:51 +00:00
} ) ;
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
$ ( document )
. bind ( 'mousemove' + namespace , function ( event ) {
var vars = wo . resizable _vars ;
// ignore mousemove if no mousedown
if ( ! vars . disabled || vars . mouseXPosition === 0 || ! vars . $target ) { return ; }
if ( wo . resizable _throttle ) {
clearTimeout ( vars . timer ) ;
vars . timer = setTimeout ( function ( ) {
ts . resizable . mouseMove ( c , wo , event ) ;
} , isNaN ( wo . resizable _throttle ) ? 5 : wo . resizable _throttle ) ;
} else {
2015-03-28 20:03:50 +00:00
ts . resizable . mouseMove ( c , wo , event ) ;
2015-07-23 04:29:51 +00:00
}
} )
. bind ( 'mouseup' + namespace , function ( ) {
if ( ! wo . resizable _vars . disabled ) { return ; }
2015-11-05 02:15:37 +00:00
ts . resizable . toggleTextSelection ( c , wo , false ) ;
2015-07-23 04:29:51 +00:00
ts . resizable . stopResize ( c , wo ) ;
ts . resizable . setHandlePosition ( c , wo ) ;
} ) ;
// resizeEnd event triggered by scroller widget
$ ( window ) . bind ( 'resize' + namespace + ' resizeEnd' + namespace , function ( ) {
2015-03-28 20:03:50 +00:00
ts . resizable . setHandlePosition ( c , wo ) ;
} ) ;
2015-07-23 04:29:51 +00:00
// right click to reset columns to default widths
c . $table
2017-01-28 19:50:22 +00:00
. bind ( 'columnUpdate pagerComplete resizableUpdate ' . split ( ' ' ) . join ( namespace + ' ' ) , function ( ) {
2015-07-23 04:29:51 +00:00
ts . resizable . setHandlePosition ( c , wo ) ;
} )
2017-01-28 19:50:22 +00:00
. bind ( 'resizableReset' + namespace , function ( ) {
ts . resizableReset ( c . table ) ;
} )
2015-07-23 04:29:51 +00:00
. find ( 'thead:first' )
. add ( $ ( c . namespace + '_extra_table' ) . find ( 'thead:first' ) )
. bind ( 'contextmenu' + namespace , function ( ) {
// $.isEmptyObject() needs jQuery 1.4+; allow right click if already reset
var allowClick = wo . resizable _vars . storedSizes . length === 0 ;
ts . resizableReset ( c . table ) ;
ts . resizable . setHandlePosition ( c , wo ) ;
wo . resizable _vars . storedSizes = [ ] ;
return allowClick ;
} ) ;
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
} ,
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
mouseMove : function ( c , wo , event ) {
if ( wo . resizable _vars . mouseXPosition === 0 || ! wo . resizable _vars . $target ) { return ; }
// resize columns
var column ,
total = 0 ,
vars = wo . resizable _vars ,
$next = vars . $next ,
tar = vars . storedSizes [ vars . target ] ,
leftEdge = event . pageX - vars . mouseXPosition ;
if ( vars . overflow ) {
if ( tar + leftEdge > 0 ) {
vars . storedSizes [ vars . target ] += leftEdge ;
ts . resizable . setWidth ( vars . $target , vars . storedSizes [ vars . target ] , true ) ;
// update the entire table width
for ( column = 0 ; column < c . columns ; column ++ ) {
total += vars . storedSizes [ column ] ;
}
ts . resizable . setWidth ( c . $table . add ( $ ( c . namespace + '_extra_table' ) ) , total ) ;
2015-06-27 02:26:44 +00:00
}
2015-07-23 04:29:51 +00:00
if ( ! $next . length ) {
// if expanding right-most column, scroll the wrapper
vars . $wrap [ 0 ] . scrollLeft = c . $table . width ( ) ;
}
} else if ( vars . fullWidth ) {
vars . storedSizes [ vars . target ] += leftEdge ;
vars . storedSizes [ vars . next ] -= leftEdge ;
ts . resizable . setWidths ( c , wo ) ;
} else {
vars . storedSizes [ vars . target ] += leftEdge ;
ts . resizable . setWidths ( c , wo ) ;
2015-06-27 02:26:44 +00:00
}
2015-07-23 04:29:51 +00:00
vars . mouseXPosition = event . pageX ;
// dynamically update sticky header widths
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'stickyHeadersUpdate' ) ;
2015-07-23 04:29:51 +00:00
} ,
stopResize : function ( c , wo ) {
var vars = wo . resizable _vars ;
ts . resizable . updateStoredSizes ( c , wo ) ;
if ( vars . useStorage ) {
// save all column widths
ts . storage ( c . table , ts . css . resizableStorage , vars . storedSizes ) ;
ts . storage ( c . table , 'tablesorter-table-resized-width' , c . $table . width ( ) ) ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
vars . mouseXPosition = 0 ;
vars . $target = vars . $next = null ;
// will update stickyHeaders, just in case, see #912
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'stickyHeadersUpdate' ) ;
2017-09-28 02:07:28 +00:00
c . $table . triggerHandler ( 'resizableComplete' ) ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ;
// this widget saves the column widths if
// $.tablesorter.storage function is included
// **************************
ts . addWidget ( {
id : 'resizable' ,
priority : 40 ,
options : {
resizable : true , // save column widths to storage
resizable _addLastColumn : false ,
2017-04-19 00:50:08 +00:00
resizable _includeFooter : true ,
2015-07-23 04:29:51 +00:00
resizable _widths : [ ] ,
resizable _throttle : false , // set to true (5ms) or any number 0-10 range
2017-04-19 00:50:08 +00:00
resizable _targetLast : false
2015-07-23 04:29:51 +00:00
} ,
init : function ( table , thisWidget , c , wo ) {
ts . resizable . init ( c , wo ) ;
} ,
2016-05-17 00:09:45 +00:00
format : function ( table , c , wo ) {
ts . resizable . setHandlePosition ( c , wo ) ;
} ,
2015-07-23 04:29:51 +00:00
remove : function ( table , c , wo , refreshing ) {
if ( wo . $resizable _container ) {
var namespace = c . namespace + 'tsresize' ;
c . $table . add ( $ ( c . namespace + '_extra_table' ) )
. removeClass ( 'hasResizable' )
. children ( 'thead' )
. unbind ( 'contextmenu' + namespace ) ;
2015-03-28 20:03:50 +00:00
wo . $resizable _container . remove ( ) ;
2015-11-05 02:15:37 +00:00
ts . resizable . toggleTextSelection ( c , wo , false ) ;
2015-07-23 04:29:51 +00:00
ts . resizableReset ( table , refreshing ) ;
$ ( document ) . unbind ( 'mousemove' + namespace + ' mouseup' + namespace ) ;
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ) ;
2015-03-28 20:03:50 +00:00
2015-07-23 04:29:51 +00:00
ts . resizableReset = function ( table , refreshing ) {
2018-03-18 13:49:07 +00:00
$ ( table ) . each ( function ( ) {
2015-07-23 04:29:51 +00:00
var index , $t ,
c = this . config ,
wo = c && c . widgetOptions ,
vars = wo . resizable _vars ;
if ( table && c && c . $headerIndexed . length ) {
// restore the initial table width
if ( vars . overflow && vars . tableWidth ) {
ts . resizable . setWidth ( c . $table , vars . tableWidth , true ) ;
if ( vars . useStorage ) {
2018-02-25 19:04:11 +00:00
ts . storage ( table , 'tablesorter-table-resized-width' , vars . tableWidth ) ;
2015-07-23 04:29:51 +00:00
}
2015-06-27 02:26:44 +00:00
}
2015-07-23 04:29:51 +00:00
for ( index = 0 ; index < c . columns ; index ++ ) {
$t = c . $headerIndexed [ index ] ;
if ( wo . resizable _widths && wo . resizable _widths [ index ] ) {
ts . resizable . setWidth ( $t , wo . resizable _widths [ index ] , vars . overflow ) ;
} else if ( ! $t . hasClass ( 'resizable-false' ) ) {
// don't clear the width of any column that is not resizable
ts . resizable . setWidth ( $t , '' , vars . overflow ) ;
}
2015-03-28 20:03:50 +00:00
}
2015-06-27 02:26:44 +00:00
2015-07-23 04:29:51 +00:00
// reset stickyHeader widths
2015-12-02 01:38:56 +00:00
c . $table . triggerHandler ( 'stickyHeadersUpdate' ) ;
2015-07-23 04:29:51 +00:00
if ( ts . storage && ! refreshing ) {
2018-02-25 19:04:11 +00:00
ts . storage ( this , ts . css . resizableStorage , [ ] ) ;
2015-07-23 04:29:51 +00:00
}
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ) ;
} ;
2015-03-28 20:03:50 +00:00
} ) ( jQuery , window ) ;
2018-03-18 13:49:07 +00:00
/*! Widget: saveSort - updated 2018-03-18 (v2.30.0) */ / *
2015-10-31 16:06:09 +00:00
* Requires tablesorter v2 . 16 +
* by Rob Garrison
* /
2015-03-28 20:03:50 +00:00
; ( function ( $ ) {
2015-07-23 04:29:51 +00:00
'use strict' ;
var ts = $ . tablesorter || { } ;
2018-03-18 13:49:07 +00:00
function getStoredSortList ( c ) {
var stored = ts . storage ( c . table , 'tablesorter-savesort' ) ;
return ( stored && stored . hasOwnProperty ( 'sortList' ) && $ . isArray ( stored . sortList ) ) ? stored . sortList : '' ;
}
function sortListChanged ( c , sortList ) {
return ( sortList || getStoredSortList ( c ) ) . join ( ',' ) !== c . sortList . join ( ',' ) ;
}
2015-07-23 04:29:51 +00:00
// this widget saves the last sort only if the
// saveSort widget option is true AND the
// $.tablesorter.storage function is included
// **************************
ts . addWidget ( {
id : 'saveSort' ,
priority : 20 ,
options : {
saveSort : true
} ,
init : function ( table , thisWidget , c , wo ) {
// run widget format before all other widgets are applied to the table
thisWidget . format ( table , c , wo , true ) ;
} ,
format : function ( table , c , wo , init ) {
2018-03-18 13:49:07 +00:00
var time ,
2015-07-23 04:29:51 +00:00
$table = c . $table ,
saveSort = wo . saveSort !== false , // make saveSort active/inactive; default to true
2018-03-18 13:49:07 +00:00
sortList = { 'sortList' : c . sortList } ,
debug = ts . debug ( c , 'saveSort' ) ;
if ( debug ) {
2015-07-23 04:29:51 +00:00
time = new Date ( ) ;
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
if ( $table . hasClass ( 'hasSaveSort' ) ) {
2018-03-18 13:49:07 +00:00
if ( saveSort && table . hasInitialized && ts . storage && sortListChanged ( c ) ) {
2015-07-23 04:29:51 +00:00
ts . storage ( table , 'tablesorter-savesort' , sortList ) ;
2018-03-18 13:49:07 +00:00
if ( debug ) {
console . log ( 'saveSort >> Saving last sort: ' + c . sortList + ts . benchmark ( time ) ) ;
2015-07-23 04:29:51 +00:00
}
}
} else {
// set table sort on initial run of the widget
$table . addClass ( 'hasSaveSort' ) ;
sortList = '' ;
// get data
if ( ts . storage ) {
2018-03-18 13:49:07 +00:00
sortList = getStoredSortList ( c ) ;
if ( debug ) {
console . log ( 'saveSort >> Last sort loaded: "' + sortList + '"' + ts . benchmark ( time ) ) ;
2015-07-23 04:29:51 +00:00
}
$table . bind ( 'saveSortReset' , function ( event ) {
event . stopPropagation ( ) ;
ts . storage ( table , 'tablesorter-savesort' , '' ) ;
} ) ;
}
// init is true when widget init is run, this will run this widget before all other widgets have initialized
// this method allows using this widget in the original tablesorter plugin; but then it will run all widgets twice.
if ( init && sortList && sortList . length > 0 ) {
c . sortList = sortList ;
} else if ( table . hasInitialized && sortList && sortList . length > 0 ) {
// update sort change
2018-03-18 13:49:07 +00:00
if ( sortListChanged ( c , sortList ) ) {
ts . sortOn ( c , sortList ) ;
}
2015-03-28 20:03:50 +00:00
}
}
2015-07-23 04:29:51 +00:00
} ,
remove : function ( table , c ) {
c . $table . removeClass ( 'hasSaveSort' ) ;
// clear storage
if ( ts . storage ) { ts . storage ( table , 'tablesorter-savesort' , '' ) ; }
2015-03-28 20:03:50 +00:00
}
2015-07-23 04:29:51 +00:00
} ) ;
2015-03-28 20:03:50 +00:00
} ) ( jQuery ) ;
2016-08-01 01:48:27 +00:00
return jQuery . tablesorter ;
2015-03-28 20:03:50 +00:00
} ) ) ;