@codenameryuu/adonis-datatable
Version:
Server side datatables package for Adonis JS
207 lines (206 loc) • 6.86 kB
JavaScript
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 = {
"&": "&",
"<": "<",
">": ">",
'"': """,
"'": "'",
};
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, "&")
.replace(/</g, "<")
.replace(/>/g, ">")
.replace(/"/g, """)
.replace(/'/g, "'")
.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;
}
}