/*! RowGroup 1.1.4 * ©2017-2021 SpryMedia Ltd - datatables.net/license */ /** * @summary RowGroup * @description RowGrouping for DataTables * @version 1.1.4 * @file dataTables.rowGroup.js * @author SpryMedia Ltd (www.sprymedia.co.uk) * @contact datatables.net * @copyright Copyright 2017-2021 SpryMedia Ltd. * * This source file is free software, available under the following license: * MIT license - http://datatables.net/license/mit * * This source file is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details. * * For details please refer to: http://www.datatables.net */ (function( factory ){ if ( typeof define === 'function' && define.amd ) { // AMD define( ['jquery', 'datatables.net'], function ( $ ) { return factory( $, window, document ); } ); } else if ( typeof exports === 'object' ) { // CommonJS module.exports = function (root, $) { if ( ! root ) { root = window; } if ( ! $ || ! $.fn.dataTable ) { $ = require('datatables.net')(root, $).$; } return factory( $, root, root.document ); }; } else { // Browser factory( jQuery, window, document ); } }(function( $, window, document, undefined ) { 'use strict'; var DataTable = $.fn.dataTable; var RowGroup = function ( dt, opts ) { // Sanity check that we are using DataTables 1.10 or newer if ( ! DataTable.versionCheck || ! DataTable.versionCheck( '1.10.8' ) ) { throw 'RowGroup requires DataTables 1.10.8 or newer'; } // User and defaults configuration object this.c = $.extend( true, {}, DataTable.defaults.rowGroup, RowGroup.defaults, opts ); // Internal settings this.s = { dt: new DataTable.Api( dt ) }; // DOM items this.dom = { }; // Check if row grouping has already been initialised on this table var settings = this.s.dt.settings()[0]; var existing = settings.rowGroup; if ( existing ) { return existing; } settings.rowGroup = this; this._constructor(); }; $.extend( RowGroup.prototype, { /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * API methods for DataTables API interface */ /** * Get/set the grouping data source - need to call draw after this is * executed as a setter * @returns string~RowGroup */ dataSrc: function ( val ) { if ( val === undefined ) { return this.c.dataSrc; } var dt = this.s.dt; this.c.dataSrc = val; $(dt.table().node()).triggerHandler( 'rowgroup-datasrc.dt', [ dt, val ] ); return this; }, /** * Disable - need to call draw after this is executed * @returns RowGroup */ disable: function () { this.c.enable = false; return this; }, /** * Enable - need to call draw after this is executed * @returns RowGroup */ enable: function ( flag ) { if ( flag === false ) { return this.disable(); } this.c.enable = true; return this; }, /** * Get enabled flag * @returns boolean */ enabled: function () { return this.c.enable; }, /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Constructor */ _constructor: function () { var that = this; var dt = this.s.dt; var hostSettings = dt.settings()[0]; dt.on( 'draw.dtrg', function (e, s) { if ( that.c.enable && hostSettings === s ) { that._draw(); } } ); dt.on( 'column-visibility.dt.dtrg responsive-resize.dt.dtrg', function () { that._adjustColspan(); } ); dt.on( 'destroy', function () { dt.off( '.dtrg' ); } ); }, /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Private methods */ /** * Adjust column span when column visibility changes * @private */ _adjustColspan: function () { $( 'tr.'+this.c.className, this.s.dt.table().body() ).find('td:visible') .attr( 'colspan', this._colspan() ); }, /** * Get the number of columns that a grouping row should span * @private */ _colspan: function () { return this.s.dt.columns().visible().reduce( function (a, b) { return a + b; }, 0 ); }, /** * Update function that is called whenever we need to draw the grouping rows. * This is basically a bootstrap for the self iterative _group and _groupDisplay * methods * @private */ _draw: function () { var dt = this.s.dt; var groupedRows = this._group( 0, dt.rows( { page: 'current' } ).indexes() ); this._groupDisplay( 0, groupedRows ); }, /** * Get the grouping information from a data set (index) of rows * @param {number} level Nesting level * @param {DataTables.Api} rows API of the rows to consider for this group * @returns {object[]} Nested grouping information - it is structured like this: * { * dataPoint: 'Edinburgh', * rows: [ 1,2,3,4,5,6,7 ], * children: [ { * dataPoint: 'developer' * rows: [ 1, 2, 3 ] * }, * { * dataPoint: 'support', * rows: [ 4, 5, 6, 7 ] * } ] * } * @private */ _group: function ( level, rows ) { var fns = Array.isArray( this.c.dataSrc ) ? this.c.dataSrc : [ this.c.dataSrc ]; var fn = DataTable.ext.oApi._fnGetObjectDataFn( fns[ level ] ); var dt = this.s.dt; var group, last; var data = []; var that = this; for ( var i=0, ien=rows.length ; i<ien ; i++ ) { var rowIndex = rows[i]; var rowData = dt.row( rowIndex ).data(); var group = fn( rowData ); if ( group === null || group === undefined ) { group = that.c.emptyDataGroup; } if ( last === undefined || group !== last ) { data.push( { dataPoint: group, rows: [] } ); last = group; } data[ data.length-1 ].rows.push( rowIndex ); } if ( fns[ level+1 ] !== undefined ) { for ( var i=0, ien=data.length ; i<ien ; i++ ) { data[i].children = this._group( level+1, data[i].rows ); } } return data; }, /** * Row group display - insert the rows into the document * @param {number} level Nesting level * @param {object[]} groups Takes the nested array from `_group` * @private */ _groupDisplay: function ( level, groups ) { var dt = this.s.dt; var display; for ( var i=0, ien=groups.length ; i<ien ; i++ ) { var group = groups[i]; var groupName = group.dataPoint; var row; var rows = group.rows; if ( this.c.startRender ) { display = this.c.startRender.call( this, dt.rows(rows), groupName, level ); row = this._rowWrap( display, this.c.startClassName, level ); if ( row ) { row.insertBefore( dt.row( rows[0] ).node() ); } } if ( this.c.endRender ) { display = this.c.endRender.call( this, dt.rows(rows), groupName, level ); row = this._rowWrap( display, this.c.endClassName, level ); if ( row ) { row.insertAfter( dt.row( rows[ rows.length-1 ] ).node() ); } } if ( group.children ) { this._groupDisplay( level+1, group.children ); } } }, /** * Take a rendered value from an end user and make it suitable for display * as a row, by wrapping it in a row, or detecting that it is a row. * @param {node|jQuery|string} display Display value * @param {string} className Class to add to the row * @param {array} group * @param {number} group level * @private */ _rowWrap: function ( display, className, level ) { var row; if ( display === null || display === '' ) { display = this.c.emptyDataGroup; } if ( display === undefined || display === null ) { return null; } if ( typeof display === 'object' && display.nodeName && display.nodeName.toLowerCase() === 'tr') { row = $(display); } else if (display instanceof $ && display.length && display[0].nodeName.toLowerCase() === 'tr') { row = display; } else { row = $('<tr/>') .append( $('<td/>') .attr( 'colspan', this._colspan() ) .append( display ) ); } return row .addClass( this.c.className ) .addClass( className ) .addClass( 'dtrg-level-'+level ); } } ); /** * RowGroup default settings for initialisation * * @namespace * @name RowGroup.defaults * @static */ RowGroup.defaults = { /** * Class to apply to grouping rows - applied to both the start and * end grouping rows. * @type string */ className: 'dtrg-group', /** * Data property from which to read the grouping information * @type string|integer|array */ dataSrc: 0, /** * Text to show if no data is found for a group * @type string */ emptyDataGroup: 'No group', /** * Initial enablement state * @boolean */ enable: true, /** * Class name to give to the end grouping row * @type string */ endClassName: 'dtrg-end', /** * End grouping label function * @function */ endRender: null, /** * Class name to give to the start grouping row * @type string */ startClassName: 'dtrg-start', /** * Start grouping label function * @function */ startRender: function ( rows, group ) { return group; } }; RowGroup.version = "1.1.4"; $.fn.dataTable.RowGroup = RowGroup; $.fn.DataTable.RowGroup = RowGroup; DataTable.Api.register( 'rowGroup()', function () { return this; } ); DataTable.Api.register( 'rowGroup().disable()', function () { return this.iterator( 'table', function (ctx) { if ( ctx.rowGroup ) { ctx.rowGroup.enable( false ); } } ); } ); DataTable.Api.register( 'rowGroup().enable()', function ( opts ) { return this.iterator( 'table', function (ctx) { if ( ctx.rowGroup ) { ctx.rowGroup.enable( opts === undefined ? true : opts ); } } ); } ); DataTable.Api.register( 'rowGroup().enabled()', function () { var ctx = this.context; return ctx.length && ctx[0].rowGroup ? ctx[0].rowGroup.enabled() : false; } ); DataTable.Api.register( 'rowGroup().dataSrc()', function ( val ) { if ( val === undefined ) { return this.context[0].rowGroup.dataSrc(); } return this.iterator( 'table', function (ctx) { if ( ctx.rowGroup ) { ctx.rowGroup.dataSrc( val ); } } ); } ); // Attach a listener to the document which listens for DataTables initialisation // events so we can automatically initialise $(document).on( 'preInit.dt.dtrg', function (e, settings, json) { if ( e.namespace !== 'dt' ) { return; } var init = settings.oInit.rowGroup; var defaults = DataTable.defaults.rowGroup; if ( init || defaults ) { var opts = $.extend( {}, defaults, init ); if ( init !== false ) { new RowGroup( settings, opts ); } } } ); return RowGroup; }));