122 lines
2.9 KiB
JavaScript
122 lines
2.9 KiB
JavaScript
/*
|
|
* Copyright (C) Sapphirecode - All Rights Reserved
|
|
* This file is part of utilities which is released under MIT.
|
|
* See file 'LICENSE' for full license details.
|
|
* Created by Timo Hocker <timo@scode.ovh>, November 2020
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
function get_element_field (element, carried_data, field) {
|
|
if (typeof carried_data[field] !== 'undefined')
|
|
return carried_data[field];
|
|
return element[field];
|
|
}
|
|
|
|
function check_filter (filter, e, carried_data) {
|
|
if (typeof filter.function !== 'undefined')
|
|
return filter.function ({ ...e, ...carried_data });
|
|
|
|
const search_str = Array.isArray (filter.field)
|
|
? filter.field.map ((f) => get_element_field (e, carried_data, f))
|
|
.filter ((v) => typeof v !== 'undefined')
|
|
.join (' ')
|
|
: get_element_field (e, carried_data, filter.field);
|
|
|
|
return filter.filter.test (search_str);
|
|
}
|
|
|
|
function check_filters (filters, e, carried_data, or = false) {
|
|
for (const filter of filters) {
|
|
let res = false;
|
|
if (Array.isArray (filter.or))
|
|
res = check_filters (filter.or, e, carried_data, true);
|
|
else
|
|
res = check_filter (filter, e, carried_data);
|
|
|
|
if (or && res)
|
|
return true;
|
|
if (!res && !or)
|
|
return false;
|
|
}
|
|
return !or;
|
|
}
|
|
|
|
/**
|
|
* @typedef Filter
|
|
* @type {object}
|
|
* @property {string|string[]} field - fields to apply filter on
|
|
* @property {RegExp} filter - filter
|
|
*/
|
|
|
|
/**
|
|
* @typedef FilterFunction
|
|
* @type {object}
|
|
* @property {function} function - function to test element for match
|
|
*/
|
|
|
|
/**
|
|
* @typedef FilterOrGroup
|
|
* @type {object}
|
|
* @property {FilterType[]} or - create an OR group of filters
|
|
*/
|
|
|
|
/**
|
|
* @typedef FilterType
|
|
* @type {Filter|FilterFunction|FilterOrGroup}
|
|
*/
|
|
|
|
/**
|
|
* filter nested objects
|
|
*
|
|
* @param {Array<object>} input object to filter
|
|
* @param {FilterType[]} filters filters
|
|
* @param {string[]} carry carry data to children to match
|
|
* @param {object} carried_data internal: carried data
|
|
* @returns {Array<object>} filtered data
|
|
*/
|
|
function recursive_filter (
|
|
input,
|
|
filters,
|
|
children_key = 'children',
|
|
carry = [],
|
|
carried_data = {}
|
|
) {
|
|
const data = [ ...input ];
|
|
const filtered = [];
|
|
|
|
for (const c of carry) {
|
|
if (typeof carried_data[c] !== 'string')
|
|
carried_data[c] = '';
|
|
}
|
|
|
|
for (let i = 0; i < data.length; i++) {
|
|
const e = { ...data[i] };
|
|
data[i] = e;
|
|
const sub_carry = { ...carried_data };
|
|
for (const c of carry) {
|
|
if (typeof e[c] !== 'undefined')
|
|
sub_carry[c] += `${sub_carry[c].length > 0 ? ' ' : ''}${e[c]}`;
|
|
}
|
|
if (check_filters (filters, e, sub_carry)) {
|
|
filtered.push (e);
|
|
}
|
|
else {
|
|
if (typeof e[children_key] === 'undefined')
|
|
continue;
|
|
e[children_key] = recursive_filter (
|
|
e[children_key],
|
|
filters,
|
|
children_key,
|
|
carry,
|
|
sub_carry
|
|
);
|
|
if (e[children_key].length > 0)
|
|
filtered.push (e);
|
|
}
|
|
}
|
|
return filtered;
|
|
}
|
|
|
|
module.exports = recursive_filter;
|