@qrvey/formula-lang/dist/cjs/errors/mismatch.js

QFormula support for qrvey projects

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateParameters = exports.FunctionArgumentsMismatch = void 0;
const constants_1 = require("../constants");
const primitiveFunctions_1 = require("../utils/primitiveFunctions");
const definitions_1 = require("./definitions");
const dictionary_1 = require("./dictionary");
class FunctionArgumentsMismatch extends definitions_1.FunctionError {
    constructor(mismatch) {
        super(mismatch.node, dictionary_1.ERROR_DICTIONARY[dictionary_1.ERROR_LIST.functionArgumentsMismatch]);
        Object.assign(this, mismatch); // Expose mismatch params to `this` class
    }
}
exports.FunctionArgumentsMismatch = FunctionArgumentsMismatch;
function validateParameters(definition, args, validators = []) {
    const received = args.map((arg) => {
        const { from, to, primitive } = arg.node;
        const singlePrimitive = (0, primitiveFunctions_1.isSinglePrimitive)(primitive)
            ? primitive
            : constants_1.AST_PRIMITIVES.UNKNOWN;
        return { from, to, primitive: singlePrimitive };
    });
    const parameters = definition.parameters || [];
    const expected = [];
    let parameterCount = 0;
    let argumentIndex = 0;
    let recursiveOptionals = false;
    while (parameterCount < parameters.length) {
        const param = parameters[parameterCount];
        const paramValidators = validators.filter((fv) => fv.argumentIndex === argumentIndex);
        const expectedPrimitive = transformParamInMismatchExpected(param, paramValidators, recursiveOptionals);
        if (expectedPrimitive.customReceived) {
            const currentReceived = received[argumentIndex];
            if (currentReceived) {
                currentReceived.customPrimitive =
                    expectedPrimitive.customReceived;
            }
            delete expectedPrimitive.customReceived;
        }
        expected.push(expectedPrimitive);
        parameterCount++;
        argumentIndex++;
        const parameterListCompleted = parameterCount === parameters.length;
        const hasMoreArguments = expected.length < received.length;
        const isRecursive = typeof (definition === null || definition === void 0 ? void 0 : definition.recursiveStartIn) === 'number';
        if (parameterListCompleted && isRecursive && hasMoreArguments) {
            parameterCount = definition.recursiveStartIn;
            recursiveOptionals = true;
        }
    }
    const validator = validators.find((val) => !val.valid);
    return { expected, received, validator };
}
exports.validateParameters = validateParameters;
function transformParamInMismatchExpected(param, paramValidators, forcedOptional) {
    const result = {
        optional: forcedOptional === true ? forcedOptional : param.optional,
    };
    const expectedInfo = getExpectedInfoFromParam(param, paramValidators);
    return Object.assign(Object.assign(Object.assign({}, result), expectedInfo), (param.generic && { generic: param.generic }));
}
function getExpectedInfoFromParam(param, paramValidators) {
    const failedValidator = paramValidators.find((val) => !val.valid && !!val.mismatchData);
    if (failedValidator) {
        return failedValidator.mismatchData;
    }
    const firstExpected = paramValidators.find((val) => !!val.mismatchData);
    if (firstExpected)
        return firstExpected.mismatchData;
    const primitive = getParamTypeFromMap(param);
    return { primitive: primitive };
}
function getParamTypeFromMap(param) {
    var _a;
    return (_a = param.expectedPrimitive) !== null && _a !== void 0 ? _a : constants_1.AST_PRIMITIVES.UNKNOWN;
}
//# sourceMappingURL=mismatch.js.map