quarkle/dist/utils/utils.js

quarkle is the JavaScript util library providing support of all data types and data structures.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.sort = exports.clone = exports.isEqual = void 0;
const compareNumbers = (number1, number2) => {
    if (number1 < number2) {
        return -1;
    }
    else if (number1 > number2) {
        return 1;
    }
    else {
        return 0;
    }
};
const compareStrings = (string1, string2) => {
    return string1.toLowerCase().localeCompare(string2.toLowerCase());
};
const compareBoolean = (flag1, flag2) => {
    return flag1 === flag2;
};
const compareArrays = (arr1, arr2) => {
    if (arr1.length !== arr2.length) {
        return false;
    }
    else {
        for (let i = 0; i < arr1.length; i++) {
            if (typeof arr1[i] !== typeof arr2[i]) {
                return false;
            }
            if ((typeof arr1[i] === "number" &&
                typeof arr2[i] === "number" &&
                compareNumbers(arr1[i], arr2[i]) !== 0) ||
                (typeof arr1[i] === "string" &&
                    typeof arr2[i] === "string" &&
                    compareStrings(arr1[i], arr2[i]) !== 0) ||
                (typeof arr1[i] === "boolean" &&
                    typeof arr2[i] === "boolean" &&
                    !compareBoolean(arr1[i], arr2[i])) ||
                (Array.isArray(arr1[i]) &&
                    Array.isArray(arr2[i]) &&
                    !compareArrays(arr1[i], arr2[i])) ||
                (typeof arr1[i] === "object" &&
                    typeof arr2[i] === "object" &&
                    !compareObjects(arr1[i], arr2[i]))) {
                return false;
            }
        }
    }
    return true;
};
const compareObjects = (obj1, obj2) => {
    const result = true;
    const keys1 = Object.keys(obj1);
    const keys2 = Object.keys(obj2);
    if (keys1.length !== keys2.length) {
        return false;
    }
    for (const key of keys1) {
        if (obj2[key] == null ||
            (typeof obj1[key] === "number" &&
                typeof obj2[key] === "number" &&
                compareNumbers(obj1[key], obj2[key]) !== 0) ||
            (typeof obj1[key] === "string" &&
                typeof obj2[key] === "string" &&
                compareStrings(obj1[key], obj2[key]) !== 0) ||
            (typeof obj1[key] === "boolean" &&
                typeof obj2[key] === "boolean" &&
                compareBoolean(obj1[key], obj2[key])) ||
            (Array.isArray(obj1[key]) &&
                Array.isArray(obj2[key]) &&
                !compareArrays(obj1[key], obj2[key])) ||
            (typeof obj1[key] === "object" &&
                typeof obj2[key] === "object" &&
                !compareObjects(obj1[key], obj2[key]))) {
            return false;
        }
    }
    return result;
};
const compare = (item1, item2) => {
    if (typeof item1 === "number" && typeof item2 === "number") {
        return compareNumbers(item1, item2);
    }
    else if (typeof item1 === "string" && typeof item2 === "string") {
        return compareStrings(item1, item2);
    }
    else if (typeof item1 === "boolean" && typeof item2 === "boolean") {
        return compareBoolean(item1, item2);
    }
    else if (Array.isArray(item1) && Array.isArray(item2)) {
        return compareArrays(item1, item2);
    }
    else if (typeof item1 === "object" && typeof item2 === "object") {
        return compareObjects(item1, item2);
    }
};
const isEqual = (item1, item2) => {
    if (typeof item1 !== typeof item2) {
        return false;
    }
    if (typeof item1 === "number" && typeof item2 === "number") {
        return compareNumbers(item1, item2) === 0;
    }
    else if (typeof item1 === "string" && typeof item2 === "string") {
        return compareStrings(item1, item2) === 0;
    }
    else if (typeof item1 === "boolean" && typeof item2 === "boolean") {
        return compareBoolean(item1, item2);
    }
    else if (Array.isArray(item1) && Array.isArray(item2)) {
        return compareArrays(item1, item2);
    }
    else if (typeof item1 === "object" && typeof item2 === "object") {
        return compareObjects(item1, item2);
    }
};
exports.isEqual = isEqual;
const cloneObject = (object) => {
    const clonedObject = {};
    const keys = Object.keys(object);
    for (const key of keys) {
        clonedObject[key] = (0, exports.clone)(object[key]);
    }
    return clonedObject;
};
const cloneArray = (array) => {
    const clonedArray = [];
    const length = array.length;
    for (let index = 0; index < length; index++) {
        const element = array[index];
        clonedArray.push((0, exports.clone)(element));
    }
    return clonedArray;
};
const clone = (item) => {
    if (typeof item === "number" ||
        typeof item === "string" ||
        typeof item === "boolean") {
        return item;
    }
    else if (Array.isArray(item)) {
        return cloneArray(item);
    }
    else if (typeof item === "object") {
        return cloneObject(item);
    }
};
exports.clone = clone;
const merge = (list, p, q, r, descending) => {
    const n1 = q - p + 1;
    const n2 = r - q;
    const left = new Array(n1);
    const right = new Array(n2);
    for (let index = 0; index < n1; index++) {
        left[index] = list[p + index];
    }
    for (let index = 0; index < n2; index++) {
        right[index] = list[q + 1 + index];
    }
    let i = 0;
    let j = 0;
    let k = p;
    while (i < n1 && j < n2) {
        const comparison = descending != null && descending
            ? compare(left[i], right[j]) === 1
            : compare(left[i], right[j]) === -1 || compare(left[i], right[j]) === 0;
        if (comparison) {
            list[k] = left[i];
            i++;
        }
        else {
            list[k] = right[j];
            j++;
        }
        k++;
    }
    while (i < n1) {
        list[k] = left[i];
        i++;
        k++;
    }
    while (j < n2) {
        list[k] = right[j];
        j++;
        k++;
    }
};
const mergeSortFunction = (list, left, right, descending) => {
    if (left < right) {
        const mid = Math.floor(left + (right - left) / 2);
        mergeSortFunction(list, left, mid, descending);
        mergeSortFunction(list, mid + 1, right, descending);
        merge(list, left, mid, right, descending);
    }
};
/**
 * Performs Sort on List
 * @param list List to be sorted
 * @param descending Sorting order, by default is ascending
 */
const sort = (list, descending) => {
    mergeSortFunction(list, 0, list.length - 1, descending);
};
exports.sort = sort;