• Home
• com.jwebmp.jre10
• jwebmp-data-tables
• 0.59.0.14
• source code
• dataTables.rowGroup.js

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

META-INF.resources.bower_components.datatables.net-rowgroup.js.dataTables.rowGroup.js Maven / Gradle / Ivy

/*! RowGroup 1.0.4
 * ©2017-2018 SpryMedia Ltd - datatables.net/license
 */

/**
 * @summary     RowGroup
 * @description RowGrouping for DataTables
 * @version     1.0.4
 * @file        dataTables.rowGroup.js
 * @author      SpryMedia Ltd (www.sprymedia.co.uk)
 * @contact     datatables.net
 * @copyright   Copyright 2017-2018 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),

            dataFn: DataTable.ext.oApi._fnGetObjectDataFn(this.c.dataSrc)
        };

        // 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;
            this.s.dataFn = DataTable.ext.oApi._fnGetObjectDataFn(this.c.dataSrc);

            $(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;
        },


        /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
         * Constructor
         */
        _constructor: function () {
            var that = this;
            var dt = this.s.dt;
            var rows = dt.rows();
            var groups = [];

            rows.every(function () {
                var d = this.data();
                var group = that.s.dataFn(d);

                if (groups.indexOf(group) == -1) {
                    groups.push(group);
                }
            });

            dt.on('draw.dtrg', function () {
                if (that.c.enable) {
                    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())
                .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
         * @private
         */
        _draw: function () {
            var that = this;
            var dt = this.s.dt;
            var rows = dt.rows({page: 'current'});
            var groupedRows = [];
            var last, display;

            rows.every(function () {
                var d = this.data();
                var group = that.s.dataFn(d);

                if (group === null || group === undefined) {
                    group = that.c.emptyDataGroup;
                }

                if (last === undefined || group !== last) {
                    groupedRows.push([]);
                    last = group;
                }

                groupedRows[groupedRows.length - 1].push(this.index());
            });

            for (var i = 0, ien = groupedRows.length; i < ien; i++) {
                var group = groupedRows[i];
                var firstRow = dt.row(group[0]);
                var groupName = this.s.dataFn(firstRow.data());
                var row;

                if (this.c.startRender) {
                    display = this.c.startRender.call(this, dt.rows(group), groupName);
                    row = this._rowWrap(display, this.c.startClassName);

                    if (row) {
                        row.insertBefore(firstRow.node());
                    }
                }

                if (this.c.endRender) {
                    display = this.c.endRender.call(this, dt.rows(group), groupName);
                    row = this._rowWrap(display, this.c.endClassName);

                    if (row) {
                        row.insertAfter(dt.row(group[group.length - 1]).node());
                    }
                }
            }
        },

        /**
         * 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
         * @private
         */
        _rowWrap: function (display, className) {
            var row;

            if (display === null || display === undefined || display === '') {
                display = this.c.emptyDataGroup;
            }

            if (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 = $('')
                    .append(
                        $('')
                            .attr('colspan', this._colspan())
                            .append(display)
                    );
            }

            return row
                .addClass(this.c.className)
                .addClass(className);
        }
    });


    /**
     * 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: 'group',

        /**
         * Data property from which to read the grouping information
         * @type string|integer
         */
        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: 'group-end',

        /**
         * End grouping label function
         * @function
         */
        endRender: null,

        /**
         * Class name to give to the start grouping row
         * @type string
         */
        startClassName: 'group-start',

        /**
         * Start grouping label function
         * @function
         */
        startRender: function (rows, group) {
            return group;
        }
    };


    RowGroup.version = "1.0.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().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;

}));