Plugins/features/fuzzySearch/dataTables.fuzzySearch.js

/*!
 * Fuzzy Search for DataTables
 * 2021 SpryMedia Ltd - datatables.net/license MIT license
 *
 * Damerau-Levenshtein function courtesy of https://github.com/tad-lispy/node-damerau-levenshtein
 * BSD 2-Clause License
 * Copyright (c) 2018, Tadeusz Łazurski
 * All rights reserved.
 */

(function( factory ){
	if ( typeof define === 'function' && define.amd ) {
		// AMD
		define( ['jquery', 'datatables.net'], function ( $ ) {
			return factory( $, window, document );
		} );
	}
	else if ( typeof exports === 'object' ) {
		// CommonJS
		var jq = require('jquery');
		var cjsRequires = function (root, $) {
			if ( ! $.fn.dataTable ) {
				require('datatables.net')(root, $);
			}
		};

		if (typeof window !== 'undefined') {
			module.exports = function (root, $) {
				if ( ! root ) {
					// CommonJS environments without a window global must pass a
					// root. This will give an error otherwise
					root = window;
				}

				if ( ! $ ) {
					$ = jq( root );
				}

				cjsRequires( root, $ );
				return factory( $, root, root.document );
			};
		}
		else {
			cjsRequires( window, jq );
			module.exports = factory( jq, window, window.document );
		}
	}
	else {
		// Browser
		factory( jQuery, window, document );
	}
}(function( $, window, document, undefined ) {
'use strict';
var DataTable = $.fn.dataTable;


function levenshtein(__this, that, limit) {
    var thisLength = __this.length, thatLength = that.length, matrix = [];
    // If the limit is not defined it will be calculate from this and that args.
    limit = (limit || (thatLength > thisLength ? thatLength : thisLength)) + 1;
    for (var i = 0; i < limit; i++) {
        matrix[i] = [i];
        matrix[i].length = limit;
    }
    for (i = 0; i < limit; i++) {
        matrix[0][i] = i;
    }
    if (Math.abs(thisLength - thatLength) > (limit || 100)) {
        return prepare(limit || 100);
    }
    if (thisLength === 0) {
        return prepare(thatLength);
    }
    if (thatLength === 0) {
        return prepare(thisLength);
    }
    // Calculate matrix.
    var j, this_i, that_j, cost, min, t;
    for (i = 1; i <= thisLength; ++i) {
        this_i = __this[i - 1];
        // Step 4
        for (j = 1; j <= thatLength; ++j) {
            // Check the jagged ld total so far
            if (i === j && matrix[i][j] > 4)
                return prepare(thisLength);
            that_j = that[j - 1];
            cost = this_i === that_j ? 0 : 1; // Step 5
            // Calculate the minimum (much faster than Math.min(...)).
            min = matrix[i - 1][j] + 1; // Devarion.
            if ((t = matrix[i][j - 1] + 1) < min)
                min = t; // Insertion.
            if ((t = matrix[i - 1][j - 1] + cost) < min)
                min = t; // Substitution.
            // Update matrix.
            matrix[i][j] =
                i > 1 &&
                    j > 1 &&
                    this_i === that[j - 2] &&
                    __this[i - 2] === that_j &&
                    (t = matrix[i - 2][j - 2] + cost) < min
                    ? t
                    : min; // Transposition.
        }
    }
    return prepare(matrix[thisLength][thatLength]);
    function prepare(steps) {
        var length = Math.max(thisLength, thatLength);
        var relative = length === 0 ? 0 : steps / length;
        var similarity = 1 - relative;
        return {
            steps: steps,
            relative: relative,
            similarity: similarity,
        };
    }
}
function fuzzySearch(searchVal, data, initial) {
    // If no searchVal has been defined then return all rows.
    if (searchVal === undefined || searchVal.length === 0) {
        return {
            pass: true,
            score: '',
        };
    }
    var threshold = initial.threshold !== undefined ? initial.threshold : 0.5;
    // Split the searchVal into individual words.
    var splitSearch = searchVal.split(/ /g);
    // Array to keep scores in
    var highestCollated = [];
    // Remove any empty words or spaces
    for (var x = 0; x < splitSearch.length; x++) {
        if (splitSearch[x].length === 0 || splitSearch[x] === ' ') {
            splitSearch.splice(x, 1);
            x--;
        }
        // Aside - Add to the score collection if not done so yet for this search word
        else if (highestCollated.length < splitSearch.length) {
            highestCollated.push({ pass: false, score: 0 });
        }
    }
    // Going to check each cell for potential matches
    for (var i = 0; i < data.length; i++) {
        // Convert all data points to lower case fo insensitive sorting
        data[i] = data[i].toLowerCase();
        // Split the data into individual words
        var splitData = data[i].split(/ /g);
        // Remove any empty words or spaces
        for (var y = 0; y < splitData.length; y++) {
            if (splitData[y].length === 0 || splitData[y] === ' ') {
                splitData.splice(y, 1);
                x--;
            }
        }
        // Check each search term word
        for (var x = 0; x < splitSearch.length; x++) {
            // Reset highest score
            var highest = {
                pass: undefined,
                score: 0,
            };
            // Against each word in the cell
            for (var y = 0; y < splitData.length; y++) {
                // If this search Term word is the beginning of the word in the cell we want to pass this word
                if (splitData[y].indexOf(splitSearch[x]) === 0) {
                    var newScore = splitSearch[x].length / splitData[y].length;
                    highest = {
                        pass: true,
                        score: highest.score < newScore ? newScore : highest.score,
                    };
                }
                // Get the levenshtein similarity score for the two words
                var steps = levenshtein(splitSearch[x], splitData[y]).similarity;
                // If the levenshtein similarity score is better than a previous one for the search word then var's store it
                if (steps > highest.score) {
                    highest.score = steps;
                }
            }
            // If this cell has a higher scoring word than previously found to the search term in the row, store it
            if (highestCollated[x].score < highest.score || highest.pass) {
                highestCollated[x] = {
                    pass: highest.pass || highestCollated[x].pass
                        ? true
                        : highest.score > threshold,
                    score: highest.score,
                };
            }
        }
    }
    // Check that all of the search words have passed
    for (var i = 0; i < highestCollated.length; i++) {
        if (!highestCollated[i].pass) {
            return {
                pass: false,
                score: Math.round((highestCollated.reduce((a, b) => a + b.score, 0) /
                    highestCollated.length) *
                    100) + '%',
            };
        }
    }
    // If we get to here, all scores greater than 0.5 so display the row
    return {
        pass: true,
        score: Math.round((highestCollated.reduce((a, b) => a + b.score, 0) /
            highestCollated.length) *
            100) + '%',
    };
}
DataTable.ext.search.push(function (settings, data, dataIndex) {
    var initial = settings.oInit.fuzzySearch;
    if (!initial) {
        return true;
    }
    // If fuzzy searching has not been implemented then pass all rows for this function
    if (settings.aoData[dataIndex]._fuzzySearch !== undefined) {
        // Read score to set the cell content and sort data
        var score = settings.aoData[dataIndex]._fuzzySearch.score;
        if (initial.rankColumn !== undefined) {
            settings.aoData[dataIndex].anCells[initial.rankColumn].innerHTML = score;
            // Remove '%' from the end of the score so can sort on a number
            settings.aoData[dataIndex]._aSortData[initial.rankColumn] =
                +score.substring(0, score.length - 1);
        }
        // Return the value for the pass as decided by the fuzzySearch function
        return settings.aoData[dataIndex]._fuzzySearch.pass;
    }
    else if (initial.rankColumn !== undefined) {
        settings.aoData[dataIndex].anCells[initial.rankColumn].innerHTML = '';
        settings.aoData[dataIndex]._aSortData[initial.rankColumn] = '';
    }
    return true;
});
$(document).on('init.dt', function (e, settings) {
    var api = new DataTable.Api(settings);
    var initial = api.init();
    var initialFuzzy = initial.fuzzySearch;
    // If this is not set then fuzzy searching is not enabled on the table so return.
    if (!initialFuzzy) {
        return;
    }
    var fromPlugin = false;
    // Find the input element
    var input = $('div.dataTables_filter input', api.table().container());
    var fontBold = {
        'font-weight': '600',
        'background-color': 'rgba(255,255,255,0.1)',
    };
    var fontNormal = {
        'font-weight': '500',
        'background-color': 'transparent',
    };
    var toggleCSS = {
        border: 'none',
        background: 'none',
        'font-size': '100%',
        width: '50%',
        display: 'inline-block',
        color: 'white',
        cursor: 'pointer',
        padding: '0.5em',
    };
    // Only going to set the toggle if it is enabled
    var toggle, tooltip, exact, fuzzy, label;
    if (typeof initialFuzzy === 'object' && initialFuzzy.toggleSmart) {
        toggle = $('<button class="toggleSearch">Abc</button>')
            .insertAfter(input)
            .css({
            border: 'none',
            background: 'none',
            position: 'relative',
            right: '33px',
            top: '0px',
            cursor: 'pointer',
            color: '#3b5e99',
            'margin-top': '1px',
        });
        exact = $('<button class="toggleSearch">Exact</button>')
            .insertAfter(input)
            .css(toggleCSS)
            .css(fontBold)
            .attr('highlighted', 'true');
        fuzzy = $('<button class="toggleSearch">Fuzzy</button>')
            .insertAfter(input)
            .css(toggleCSS);
        input.css({
            'padding-right': '30px',
        });
        $(input.parent()).css('right', '-33px').css('position', 'relative');
        label = $('<div>Search Type<div>').css({
            'padding-bottom': '0.5em',
            'font-size': '0.8em',
        });
        tooltip = $('<div class="fuzzyToolTip"></div>')
            .css({
            position: 'absolute',
            top: '2em',
            background: 'white',
            'border-radius': '4px',
            'text-align': 'center',
            padding: '0.5em',
            'background-color': '#16232a',
            'box-shadow': '4px 4px 4px rgba(0, 0, 0, 0.5)',
            color: 'white',
            transition: 'opacity 0.25s',
            'z-index': '30001',
            width: input.outerWidth() - 3,
        })
            .append(label)
            .append(exact)
            .append(fuzzy);
    }
    function toggleFuzzy(event) {
        if (toggle.attr('blurred')) {
            toggle.css({ filter: 'blur(0px)' }).removeAttr('blurred');
            fuzzy.removeAttr('highlighted').css(fontNormal);
            exact.attr('highlighted', true).css(fontBold);
        }
        else {
            toggle.css({ filter: 'blur(1px)' }).attr('blurred', true);
            exact.removeAttr('highlighted').css(fontNormal);
            fuzzy.attr('highlighted', true).css(fontBold);
        }
        // Whenever the search mode is changed we need to re-search
        triggerSearchFunction(event);
    }
    // Turn off the default datatables searching events
    $(settings.nTable).off('search.dt.DT');
    var fuzzySearchVal = '';
    var searchVal = '';
    // The function that we want to run on search
    var triggerSearchFunction = function (event) {
        // If the search is only to be triggered on return wait for that
        if ((event.type === 'input' &&
            (initial.search === undefined || !initial.search.return)) ||
            event.key === 'Enter' ||
            event.type === 'click') {
            // If the toggle is set and isn't checkd then perform a normal search
            if (toggle && !toggle.attr('blurred')) {
                api.rows().iterator('row', function (settings, rowIdx) {
                    settings.aoData[rowIdx]._fuzzySearch = undefined;
                }, false);
                searchVal = input.val();
                fuzzySearchVal = searchVal;
                fromPlugin = true;
                api.search(searchVal);
                fromPlugin = false;
                searchVal = '';
            }
            // Otherwise perform a fuzzy search
            else {
                // Get the value from the input element and convert to lower case
                fuzzySearchVal = input.val();
                searchVal = '';
                if (fuzzySearchVal !== undefined && fuzzySearchVal.length !== 0) {
                    fuzzySearchVal = fuzzySearchVal.toLowerCase();
                }
                // For each row call the fuzzy search function to get result
                api.rows().iterator('row', function (settings, rowIdx) {
                    settings.aoData[rowIdx]._fuzzySearch = fuzzySearch(fuzzySearchVal, settings.aoData[rowIdx]._aFilterData, initialFuzzy);
                }, false);
                fromPlugin = true;
                // Empty the datatables search and replace it with our own
                api.search('');
                input.val(fuzzySearchVal);
                fromPlugin = false;
            }
            fromPlugin = true;
            api.draw();
            fromPlugin = false;
        }
    };
    var apiRegister = DataTable.Api.register;
    apiRegister('search.fuzzy()', function (value) {
        if (value === undefined) {
            return fuzzySearchVal;
        }
        else {
            fuzzySearchVal = value.toLowerCase();
            searchVal = api.search();
            input.val(fuzzySearchVal);
            // For each row call the fuzzy search function to get result
            api.rows().iterator('row', function (settings, rowIdx) {
                settings.aoData[rowIdx]._fuzzySearch = fuzzySearch(fuzzySearchVal, settings.aoData[rowIdx]._aFilterData, initialFuzzy);
            }, false);
            // triggerSearchFunction({key: 'Enter'});
            return this;
        }
    });
    input.off();
    // Set listeners to occur on toggle and typing
    if (toggle) {
        // Highlights one of the buttons in the tooltip and un-highlights the other
        function highlightButton(toHighlight, event) {
            if (!toHighlight.attr('highlighted')) {
                toggleFuzzy(event);
            }
        }
        // Removes the tooltip element
        function removeToolTip() {
            tooltip.remove();
        }
        // Actions for the toggle button
        toggle
            .on('click', toggleFuzzy)
            .on('mouseenter', function () {
            tooltip.insertAfter(toggle).on('mouseleave', removeToolTip);
            tooltip.css('left', input.position().left + 3);
            exact.on('click', event => highlightButton(exact, event));
            fuzzy.on('click', event => highlightButton(fuzzy, event));
        })
            .on('mouseleave', removeToolTip);
        // Actions for the input element
        input
            .on('mouseenter', function () {
            tooltip.insertAfter(toggle).on('mouseleave', removeToolTip);
            tooltip.css('left', input.position().left + 3);
            exact.on('click', event => highlightButton(exact, event));
            fuzzy.on('click', event => highlightButton(fuzzy, event));
        })
            .on('mouseleave', function () {
            var inToolTip = false;
            tooltip.on('mouseenter', () => (inToolTip = true));
            toggle.on('mouseenter', () => (inToolTip = true));
            setTimeout(function () {
                if (!inToolTip) {
                    removeToolTip();
                }
            }, 250);
        });
        var state = api.state.loaded();
        api.on('stateSaveParams', function (e, settings, data) {
            data._fuzzySearch = {
                active: toggle.attr('blurred'),
                val: input.val(),
            };
        });
        if (state !== null && state._fuzzySearch !== undefined) {
            input.val(state._fuzzySearch.val);
            if (state._fuzzySearch.active === 'true') {
                toggle.click();
                api.page(state.start / state.length).draw('page');
            }
        }
    }
    api.on('search', function () {
        if (!fromPlugin) {
            input.val(api.search() !== searchVal ? api.search() : fuzzySearchVal);
        }
    });
    // Always add this event no matter if toggling is enabled
    input.on('input keydown', triggerSearchFunction);
});


return DataTable;
}));