@codenameryuu/adonis-datatable/build/src/utils/helper.js

Package server side datatables on AdonisJS 6

import lodash from 'lodash';
import { Edge } from 'edge.js';
export default class Helper {
    static toSnakeCase(str) {
        return str.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
    }
    static wrapColumn(value, toSnackCase = true) {
        if (value.includes(' as ')) {
            const [column, alias] = value.split(' as ');
            return `\`${column.trim()}\` as \`${alias.trim()}\``;
        }
        return value
            .split('.')
            .map((segment) => `\`${toSnackCase ? Helper.toSnakeCase(segment) : segment}\``)
            .join('.');
    }
    static escape(value) {
        if (typeof value === 'string') {
            return value.replace(/[&<>"']/g, (match) => {
                const escapeChars = {
                    '&': '&amp;',
                    '<': '&lt;',
                    '>': '&gt;',
                    '"': '&quot;',
                    "'": '&#039;',
                };
                return escapeChars[match];
            });
        }
        return value;
    }
    static extractColumnName(str, wantsAlias) {
        const matches = str.toLowerCase().split(' as ');
        if (matches.length > 1) {
            if (wantsAlias) {
                return matches.pop();
            }
            return matches.shift();
        }
        else if (str.includes('.')) {
            const array = str.split('.');
            return array.pop();
        }
        return str;
    }
    static wildcardString(str, wildcard, lowercase = true) {
        let wild = wildcard;
        const chars = [...str];
        if (chars.length > 0) {
            for (const char of chars) {
                wild += char + wildcard;
            }
        }
        if (lowercase) {
            wild = wild.toLowerCase();
        }
        return wild;
    }
    static only(obj, keys) {
        return Object.keys(obj)
            .filter((key) => keys.includes(key))
            .reduce((result, key) => {
            result[key] = obj[key];
            return result;
        }, {});
    }
    static value(defaultVal, ...args) {
        return typeof defaultVal === 'function' ? defaultVal(args) : defaultVal;
    }
    static serializeToObject(row) {
        if (row && typeof row['serialize'] === 'function' && typeof row === 'object') {
            row.serializeExtras = () => row.$extras;
            let data = row.serialize();
            if (typeof row['serializeRelations'] === 'function') {
                for (const [relationName, relation] of Object.entries(row.serializeRelations())) {
                    if (Array.isArray(relation)) {
                        const items = [];
                        for (const relationItem of Object.values(row.$getRelated(relationName))) {
                            items.push(Helper.serializeToObject(relationItem));
                        }
                        data[relationName] = items;
                    }
                    else {
                        data[relationName] = Helper.serializeToObject(row.$getRelated(relationName));
                    }
                }
            }
            return data;
        }
        return row;
    }
    static compileContent(content, data, row) {
        if (typeof content === 'string') {
            return Helper.compileView(content, Helper.getMixedValue(data, row));
        }
        if (typeof content === 'function') {
            return content(row);
        }
        return content;
    }
    static compileView(content, data) {
        const edge = Edge.create();
        return edge.renderRawSync(content, data);
    }
    static escapeHTML(html) {
        return html
            .replace(/&/g, '&amp;')
            .replace(/</g, '&lt;')
            .replace(/>/g, '&gt;')
            .replace(/"/g, '&quot;')
            .replace(/'/g, '&#039;')
            .replace(/\\/g, '\\\\')
            .replace(/\n/g, '\\n');
    }
    static getMixedValue(data, param) {
        const casted = Helper.toObject(param);
        data['model'] = param;
        for (const key of Object.keys(data)) {
            if (casted[key] !== undefined) {
                data[key] = casted[key];
            }
        }
        lodash.unset(data, 'model');
        return data;
    }
    static toObject(param) {
        if (typeof param['toJSON'] === 'function' && typeof param === 'object') {
            return param.toJSON();
        }
        if (Array.isArray(param)) {
            return Object.assign({}, param);
        }
        return param;
    }
    static dot(object, prepend = '') {
        let results = {};
        for (const key in object) {
            if (object.hasOwnProperty(key)) {
                const value = object[key];
                if (typeof value === 'object' &&
                    value !== null &&
                    !Array.isArray(value) &&
                    Object.keys(value).length > 0) {
                    results = { ...results, ...Helper.dot(value, `${prepend}${key}.`) };
                }
                else {
                    results[`${prepend}${key}`] = value;
                }
            }
        }
        return results;
    }
    static contains(haystack, needles, ignoreCase = false) {
        if (ignoreCase) {
            haystack = haystack.toLowerCase();
        }
        if (!Array.isArray(needles)) {
            needles = [needles];
        }
        for (let needle of needles) {
            if (ignoreCase) {
                needle = needle.toLowerCase();
            }
            if (needle !== '' && haystack.includes(needle)) {
                return true;
            }
        }
        return false;
    }
    static objectIncludeIn(item, data) {
        const isItemOrderInvalid = (i, a) => {
            return i.order >= Object.keys(a).length;
        };
        if (isItemOrderInvalid(item, data)) {
            return { ...data, [item.name]: item.content };
        }
        let count = 0;
        const first = {};
        const last = { ...data };
        for (const key in data) {
            if (count === item.order) {
                continue;
            }
            delete last[key];
            first[key] = data[key];
            count++;
        }
        return { ...first, [item.name]: item.content, ...last };
    }
    static objectIntersectKey(array, keys) {
        return Object.keys(array)
            .filter((key) => keys.includes(key))
            .reduce((result, key) => {
            result[key] = array[key];
            return result;
        }, {});
    }
    static objectReplaceRecursive(target, source) {
        for (const key in source) {
            if (source[key] instanceof Object && key in target) {
                target[key] = Helper.objectReplaceRecursive(target[key], source[key]);
            }
            else {
                target[key] = source[key];
            }
        }
        return target;
    }
}