@hestia-earth/schema/utils/sort.js

HESTIA Schema

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.sortKeysByType = void 0;
var types_1 = require("./types");
var defaultSortConfig = require('../sort-config/config.json');
var typeSortOrder = function (sortConfig, type, key) {
    return type in sortConfig && key in sortConfig[type]
        ? sortConfig[type][key]
        : {
            order: Number.MAX_SAFE_INTEGER.toString(),
            type: 'string'
        };
};
var keyDelimiter = '.';
var isNumber = function (key) { return key.match(/^\d+$/g) !== null; };
var keyParts = function (key) { return key.split(keyDelimiter); };
var typeLevel = function (sortConfig, type) { return sortConfig[type].index.order; };
var maxLevelByType = function (sortConfig, type) { return sortConfig[type].type.order.length; };
var sortOrder = function (sortConfig, maxNestedLevel) {
    if (maxNestedLevel === void 0) { maxNestedLevel = 1; }
    return function (fullKey, parentType) {
        var _a = __read(keyParts(fullKey)), keyType = _a[0], key = _a[1], left = _a.slice(2);
        var keyAsNumber = isNumber(key);
        var nestedKey = __spreadArray([key], __read(left), false).join(keyDelimiter);
        var schemaType = (0, types_1.typeToSchemaType)(parentType || keyType);
        var _b = keyAsNumber
            ? { order: key.padStart(maxLevelByType(sortConfig, parentType), '0'), type: parentType }
            : typeSortOrder(sortConfig, schemaType, key), order = _b.order, type = _b.type;
        var nestedOrder = left.length ? sortOrder(sortConfig, maxNestedLevel)(nestedKey, type) : '';
        var fullOrder = (order + nestedOrder).padEnd(parentType ? 0 : maxNestedLevel * order.length, '0');
        return parentType ? fullOrder : typeLevel(sortConfig, schemaType) + fullOrder;
    };
};
var sortKeysByType = function (keys, sort, sortConfig) {
    if (sort === void 0) { sort = 'asc'; }
    if (sortConfig === void 0) { sortConfig = defaultSortConfig; }
    var maxNestedLevel = keys
        .map(function (key) { return keyParts(key).length; })
        .sort()
        .pop();
    var sorter = sortOrder(sortConfig, maxNestedLevel);
    var orders = keys.reduce(function (prev, key) {
        var _a;
        return (__assign(__assign({}, prev), (_a = {}, _a[key] = sorter(key), _a)));
    }, {});
    return keys.sort(function (a, b) {
        return sort === 'asc'
            ? parseInt(orders[a], 10) - parseInt(orders[b], 10)
            : parseInt(orders[b], 10) - parseInt(orders[a], 10);
    });
};
exports.sortKeysByType = sortKeysByType;