@sap/adp-abap/dist/services/FlpParameters.js

abap service for all yeoman generators

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.stringifyParameters = exports.parseFlpParamString = exports.validateFlpParamString = void 0;
const genericErrorMessage = (error) => `Value cannot be parsed: ${error}! Please check the entered value and if needed create ticket for the application component in order to get the proper value.`;
function validateFlpParamString(paramString) {
    if (!paramString) {
        return true;
    }
    try {
        parseFlpParamString(paramString);
    }
    catch (error) {
        return error.message;
    }
    return true;
}
exports.validateFlpParamString = validateFlpParamString;
function parseFlpParamString(paramString) {
    let result = {};
    const modifiedParamString = addMissingAmpersands(paramString);
    const params = modifiedParamString
        .split("&")
        .map((el) => el.trim())
        .filter((el) => el !== "");
    params.forEach((param) => {
        const isMandatory = rules.isMandatoryParam(param);
        if (!isMandatory) {
            param = param.replace(/[()]/g, "");
        }
        const isEmptyParamCheck = rules.isEmptyParam(param);
        if (isEmptyParamCheck.shouldApply) {
            checkForDuplicatedKeys(result, isEmptyParamCheck.value);
            const emptyParam = {};
            emptyParam[isEmptyParamCheck.value] = {};
            result = Object.assign(result, emptyParam);
        }
        else {
            const paramParts = param
                .split("=")
                .map((el) => el.trim())
                .filter((el) => el !== "");
            if (paramParts.length <= 1 || paramParts.length > 3) {
                throw new SyntaxError(genericErrorMessage("Invalid parameters string"));
            }
            result = Object.assign(result, construct(paramParts, isMandatory, result));
        }
    });
    return result;
}
exports.parseFlpParamString = parseFlpParamString;
function addMissingAmpersands(value) {
    return value.replace(/[)]\s*[(]/gm, ")&(");
}
function checkForDuplicatedKeys(parameters, key) {
    Object.keys(parameters).forEach((existingKey) => {
        if (existingKey === key) {
            throw new Error(genericErrorMessage(`Duplicated parameter: '${key}'`));
        }
    });
}
function construct(parts, isMandatory, parameters) {
    const resultObject = {};
    const paramName = parts[0];
    checkForDuplicatedKeys(parameters, paramName);
    resultObject[paramName] = {
        required: isMandatory
    };
    if (parts.length === 2) {
        const shouldRenameCheck = rules.shouldRenameTo(parts[1]);
        if (shouldRenameCheck.shouldApply) {
            resultObject[paramName].renameTo = shouldRenameCheck.value;
            return resultObject;
        }
        applyRules(resultObject[paramName], parts[1]);
        return resultObject;
    }
    const secondParamPart = parts[1];
    const thirdParamPart = parts[2];
    applyRules(resultObject[paramName], secondParamPart);
    const shouldRenameCheck = rules.shouldRenameTo(thirdParamPart);
    if (shouldRenameCheck.shouldApply) {
        resultObject[paramName].renameTo = shouldRenameCheck.value;
    }
    return resultObject;
}
function applyRules(resultObject, paramPartString) {
    const shouldFilterDefaultValueCheck = rules.shouldHavеFiltertValue(paramPartString);
    const isReferenceCheck = rules.isReference(paramPartString);
    if (shouldFilterDefaultValueCheck.shouldApply && !isReferenceCheck.shouldApply) {
        resultObject.filter = {
            value: shouldFilterDefaultValueCheck.value,
            format: "plain"
        };
    }
    else if (!shouldFilterDefaultValueCheck.shouldApply && !isReferenceCheck.shouldApply) {
        resultObject.defaultValue = {
            value: paramPartString,
            format: "plain"
        };
    }
    else {
        resultObject.defaultValue = {
            value: isReferenceCheck.value,
            format: "reference"
        };
    }
}
const defaultParamCheck = { shouldApply: false, value: undefined };
const rules = {
    isEmptyParam: (paramString) => {
        if (/^.+=\s*$/g.test(paramString)) {
            return {
                shouldApply: true,
                value: paramString.replace(/=/g, "").trim()
            };
        }
        return defaultParamCheck;
    },
    isMandatoryParam: (paramString) => {
        return !(paramString.trim().startsWith("(") && paramString.trim().endsWith(")"));
    },
    shouldHavеFiltertValue: (paramString) => {
        if (paramString.startsWith("<") && paramString.endsWith(">")) {
            return {
                shouldApply: true,
                value: paramString.replace(/[<>]/g, "")
            };
        }
        return defaultParamCheck;
    },
    shouldRenameTo: (paramString) => {
        if (paramString.trim().startsWith(">")) {
            return {
                shouldApply: true,
                value: paramString.trim().replace(/>/g, "")
            };
        }
        return defaultParamCheck;
    },
    isReference: (paramString) => {
        if (paramString.startsWith("%%") && paramString.endsWith("%%")) {
            return {
                shouldApply: true,
                value: paramString.replace(/%/g, "")
            };
        }
        return defaultParamCheck;
    }
};
function stringifyParameters(parameters) {
    const result = [];
    for (const [key, options] of Object.entries(parameters)) {
        let paramString = key;
        if (JSON.stringify(options) === "{}") {
            paramString = `(${paramString} = )`;
        }
        if (options.filter) {
            paramString += `=<${options.filter.value}>`;
        }
        else if (options.defaultValue) {
            if (options.defaultValue.format === "reference") {
                paramString += `=%%${options.defaultValue.value}%%`;
            }
            else {
                paramString += `=${options.defaultValue.value}`;
            }
        }
        if (options.renameTo) {
            paramString += `=>${options.renameTo}`;
        }
        if (options.required === false) {
            paramString = `(${paramString})`;
        }
        result.push(paramString);
    }
    return result.join("&");
}
exports.stringifyParameters = stringifyParameters;
//# sourceMappingURL=FlpParameters.js.map