@nativescript/core/ui/builder/binding-builder.js

// regex that contains all symbols applicable for expression used to AI detect an expression.
const expressionSymbolsRegex = /[\+\-\*\/%\?:<>=!\|&\(\)^~]|^`.*\$\{.+\}.*`$/;
export var bindingConstants;
(function (bindingConstants) {
    bindingConstants.sourceProperty = 'sourceProperty';
    bindingConstants.targetProperty = 'targetProperty';
    bindingConstants.expression = 'expression';
    bindingConstants.twoWay = 'twoWay';
    bindingConstants.source = 'source';
    bindingConstants.bindingValueKey = '$value';
    bindingConstants.parentValueKey = '$parent';
    bindingConstants.parentsValueKey = '$parents';
    bindingConstants.newPropertyValueKey = '$newPropertyValue';
})(bindingConstants || (bindingConstants = {}));
const hasEqualSignRegex = /=+/;
const equalSignComparisionOperatorsRegex = /(==|===|>=|<=|!=|!==)/;
// this regex is used to search for all instaces of '$parents[]' within an expression
export const parentsRegex = /\$parents\s*\[\s*(['"]*)\w*\1\s*\]/g;
function isNamedParam(value) {
    const equalSignIndex = value.search(hasEqualSignRegex);
    if (equalSignIndex > -1) {
        const equalSignSurround = value.substr(equalSignIndex > 0 ? equalSignIndex - 1 : 0, 3);
        if (equalSignSurround.search(equalSignComparisionOperatorsRegex) === -1) {
            return true;
        }
    }
    return false;
}
function areNamedParams(params) {
    for (let i = 0; i < params.length; i++) {
        if (isNamedParam(params[i])) {
            return true;
        }
    }
    return false;
}
const namedParamConstants = {
    propName: 'propName',
    propValue: 'propValue',
};
function getPropertyNameValuePair(param, knownOptions, callback) {
    let nameValuePair = {};
    let propertyName = param.substr(0, param.indexOf('=')).trim();
    const propertyValue = param.substr(param.indexOf('=') + 1).trim();
    if (knownOptions) {
        if (!propertyName) {
            propertyName = knownOptions.defaultProperty;
        }
        else {
            propertyName = propertyName in knownOptions ? propertyName : null;
        }
    }
    if (propertyName) {
        if (callback) {
            nameValuePair = callback(propertyName, propertyValue);
        }
        else {
            nameValuePair[namedParamConstants.propName] = propertyName;
            nameValuePair[namedParamConstants.propValue] = propertyValue;
        }
        return nameValuePair;
    }
    return null;
}
function parseNamedProperties(parameterList, knownOptions, callback) {
    const result = {};
    let nameValuePair;
    for (let i = 0; i < parameterList.length; i++) {
        nameValuePair = getPropertyNameValuePair(parameterList[i], knownOptions, callback);
        if (nameValuePair) {
            result[nameValuePair[namedParamConstants.propName]] = nameValuePair[namedParamConstants.propValue];
        }
    }
    return result;
}
function getParamsArray(value) {
    const result = [];
    let skipComma = 0;
    let indexReached = 0;
    let singleQuoteBlock = false;
    let doubleQuoteBlock = false;
    for (let i = 0; i < value.length; i++) {
        if (value[i] === '"') {
            doubleQuoteBlock = !doubleQuoteBlock;
        }
        if (value[i] === "'") {
            singleQuoteBlock = !singleQuoteBlock;
        }
        if (value[i] === '(' || value[i] === '[') {
            skipComma++;
        }
        if (value[i] === ')' || value[i] === ']') {
            skipComma--;
        }
        if (value[i] === ',' && skipComma === 0 && !(singleQuoteBlock || doubleQuoteBlock)) {
            result.push(value.substr(indexReached, i - indexReached));
            indexReached = i + 1;
        }
    }
    result.push(value.substr(indexReached));
    return result;
}
function isExpression(expression) {
    if (expression.search(expressionSymbolsRegex) > -1) {
        const parentsMatches = expression.match(parentsRegex);
        if (parentsMatches) {
            const restOfExpression = expression.substr(expression.indexOf(parentsMatches[0]) + parentsMatches[0].length);
            // no more expression regognition symbols so it is safe for sourceProperty
            if (!(restOfExpression.search(expressionSymbolsRegex) > -1)) {
                return false;
            }
        }
        return true;
    }
    return false;
}
export function getBindingOptions(name, value) {
    let namedParams = [];
    const params = getParamsArray(value);
    if (!areNamedParams(params)) {
        if (params.length === 1) {
            const trimmedValue = params[0].trim();
            let sourceProp;
            if (isExpression(trimmedValue)) {
                sourceProp = bindingConstants.bindingValueKey;
                namedParams.push(bindingConstants.expression + ' = ' + trimmedValue);
            }
            else {
                sourceProp = trimmedValue;
            }
            namedParams.push(bindingConstants.sourceProperty + ' = ' + sourceProp);
            namedParams.push(bindingConstants.twoWay + ' = true');
        }
        else {
            namedParams.push(bindingConstants.sourceProperty + ' = ' + params[0].trim());
            namedParams.push(bindingConstants.expression + ' = ' + params[1].trim());
            const twoWay = params[2] ? params[2].toLowerCase().trim() === 'true' : true;
            namedParams.push(bindingConstants.twoWay + ' = ' + twoWay);
        }
    }
    else {
        namedParams = params;
    }
    const bindingPropertyHandler = function (prop, value) {
        const result = {};
        result[namedParamConstants.propName] = prop;
        if (prop === bindingConstants.twoWay) {
            // create a real boolean value
            if (value === 'true') {
                result[namedParamConstants.propValue] = true;
            }
            else {
                result[namedParamConstants.propValue] = false;
            }
        }
        else {
            result[namedParamConstants.propValue] = value;
        }
        return result;
    };
    const bindingOptionsParameters = parseNamedProperties(namedParams, xmlBindingProperties, bindingPropertyHandler);
    const bindOptions = {
        targetProperty: name,
    };
    for (const prop in bindingOptionsParameters) {
        if (bindingOptionsParameters.hasOwnProperty(prop)) {
            bindOptions[prop] = bindingOptionsParameters[prop];
        }
    }
    if (bindOptions[bindingConstants.twoWay] === undefined) {
        bindOptions[bindingConstants.twoWay] = true;
    }
    return bindOptions;
}
const xmlBindingProperties = {
    sourceProperty: true,
    expression: true,
    twoWay: true,
    source: true,
    defaultProperty: bindingConstants.sourceProperty,
};
//# sourceMappingURL=binding-builder.js.map