@bitblit/ratchet-misc/lib/handlebars/handlebars-ratchet.js

Ratchet miscellaneous tooling that requires smallish dependant libraries

import { Logger } from '@bitblit/ratchet-common/logger/logger';
import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
import { NumberRatchet } from '@bitblit/ratchet-common/lang/number-ratchet';
export class HandlebarsRatchet {
    constructor() { }
    static functionMap() {
        return {
            eq: HandlebarsRatchet.equal,
            ne: HandlebarsRatchet.notEqual,
            lt: HandlebarsRatchet.lessThan,
            gt: HandlebarsRatchet.greaterThan,
            lte: HandlebarsRatchet.lessThanEqual,
            gte: HandlebarsRatchet.greaterThanEqual,
            and: HandlebarsRatchet.and,
            or: HandlebarsRatchet.or,
            formatBytes: HandlebarsRatchet.formatBytes,
            rpn: HandlebarsRatchet.reversePolishNotation,
            add: HandlebarsRatchet.add,
            sub: HandlebarsRatchet.sub,
            mul: HandlebarsRatchet.mul,
            div: HandlebarsRatchet.div,
            mod: HandlebarsRatchet.mod,
            maxNum: HandlebarsRatchet.maxNum,
            minNum: HandlebarsRatchet.minNum,
        };
    }
    static registerAll(handlebars) {
        handlebars.registerHelper(HandlebarsRatchet.functionMap());
    }
    static add(v1, v2) {
        return NumberRatchet.safeNumber(v1) + NumberRatchet.safeNumber(v2);
    }
    static sub(v1, v2) {
        return NumberRatchet.safeNumber(v1) - NumberRatchet.safeNumber(v2);
    }
    static mul(v1, v2) {
        return NumberRatchet.safeNumber(v1) * NumberRatchet.safeNumber(v2);
    }
    static div(v1, v2) {
        return NumberRatchet.safeNumber(v1) / NumberRatchet.safeNumber(v2);
    }
    static mod(v1, v2) {
        return NumberRatchet.safeNumber(v1) % NumberRatchet.safeNumber(v2);
    }
    static equal(v1, v2) {
        return v1 === v2;
    }
    static notEqual(v1, v2) {
        return v1 !== v2;
    }
    static lessThan(v1, v2) {
        return v1 < v2;
    }
    static lessThanEqual(v1, v2) {
        return v1 <= v2;
    }
    static greaterThan(v1, v2) {
        return v1 > v2;
    }
    static greaterThanEqual(v1, v2) {
        return v1 >= v2;
    }
    static maxNum(...args) {
        return Math.max(...args.slice(0, -1));
    }
    static minNum(...args) {
        return Math.min(...args.slice(0, -1));
    }
    static and(...args) {
        return Array.prototype.every.call(args, Boolean);
    }
    static or(...args) {
        return Array.prototype.slice.call(args, 0, -1).some(Boolean);
    }
    static formatBytes(v1) {
        return StringRatchet.formatBytes(v1);
    }
    static reversePolishNotation(...args) {
        let rval = null;
        try {
            const fns = Object.assign({}, HandlebarsRatchet.functionMap());
            delete fns['formatBytes'];
            const stack = [];
            for (let i = 0; i < args.length - 1; i++) {
                const a = args[i];
                if (fns[a]) {
                    if (stack.length > 1) {
                        const op2 = stack.pop();
                        const op1 = stack.pop();
                        const res = fns[a](op1, op2, {});
                        stack.push(res);
                    }
                    else {
                        ErrorRatchet.throwFormattedErr('Cannot execute operation %s - not enough args', a);
                    }
                }
                else {
                    stack.push(a);
                }
            }
            rval = stack.pop();
        }
        catch (err) {
            Logger.error('Failed to execute RPN: %s', err, err);
            rval = ErrorRatchet.asErr(err)?.message || 'Failure';
        }
        return rval;
    }
}
//# sourceMappingURL=handlebars-ratchet.js.map