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

QFormula support for qrvey projects

import { AST_PRIMITIVES } from '../constants';
import { isSinglePrimitive } from '../utils/primitiveFunctions';
import { FunctionError } from './definitions';
import { ERROR_DICTIONARY, ERROR_LIST } from './dictionary';
export class FunctionArgumentsMismatch extends FunctionError {
    constructor(mismatch) {
        super(mismatch.node, ERROR_DICTIONARY[ERROR_LIST.functionArgumentsMismatch]);
        Object.assign(this, mismatch); // Expose mismatch params to `this` class
    }
}
export function validateParameters(definition, args, validators = []) {
    const received = args.map((arg) => {
        const { from, to, type, primitive } = arg.node;
        const singlePrimitive = isSinglePrimitive(primitive)
            ? primitive
            : AST_PRIMITIVES.UNKNOWN;
        return { from, to, type, 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 };
}
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 : AST_PRIMITIVES.UNKNOWN;
}
//# sourceMappingURL=mismatch.js.map