@stylable/core/cjs/stylable-value-parsers.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateAllowedNodesUntil = exports.listOptions = exports.strategies = exports.groupValues = exports.getStringValue = exports.getFormatterArgs = exports.getNamedArgs = exports.SBTypesParsers = exports.STYLABLE_NAMED_MATCHER = exports.STYLABLE_VALUE_MATCHER = exports.stValuesMap = exports.stValues = exports.mixinDeclRegExp = exports.valueMapping = exports.rootValueMapping = exports.valueParserWarnings = void 0;
const postcss_value_parser_1 = __importDefault(require("postcss-value-parser"));
const pseudo_states_1 = require("./pseudo-states");
const selector_utils_1 = require("./selector-utils");
exports.valueParserWarnings = {
    VALUE_CANNOT_BE_STRING() {
        return 'value can not be a string (remove quotes?)';
    },
    CSS_MIXIN_FORCE_NAMED_PARAMS() {
        return 'CSS mixins must use named parameters (e.g. "func(name value, [name value, ...])")';
    },
    INVALID_NAMED_IMPORT_AS(name) {
        return `Invalid named import "as" with name "${name}"`;
    },
    INVALID_NESTED_KEYFRAMES(name) {
        return `Invalid nested keyframes import "${name}"`;
    },
};
exports.rootValueMapping = {
    vars: ':vars',
    import: ':import',
    stScope: 'st-scope',
    namespace: 'namespace',
};
exports.valueMapping = {
    from: '-st-from',
    named: '-st-named',
    default: '-st-default',
    root: '-st-root',
    states: '-st-states',
    extends: '-st-extends',
    mixin: '-st-mixin',
    partialMixin: '-st-partial-mixin',
    global: '-st-global',
};
exports.mixinDeclRegExp = new RegExp(`(${exports.valueMapping.mixin})|(${exports.valueMapping.partialMixin})`);
exports.stValues = Object.keys(exports.valueMapping).map((key) => exports.valueMapping[key]);
exports.stValuesMap = Object.keys(exports.valueMapping).reduce((acc, key) => {
    acc[exports.valueMapping[key]] = true;
    return acc;
}, {});
exports.STYLABLE_VALUE_MATCHER = /^-st-/;
exports.STYLABLE_NAMED_MATCHER = new RegExp(`^${exports.valueMapping.named}-(.+)`);
exports.SBTypesParsers = {
    '-st-root'(value) {
        return value === 'false' ? false : true;
    },
    '-st-global'(decl, _diagnostics) {
        // Experimental
        const selector = selector_utils_1.parseSelector(decl.value.replace(/^['"]/, '').replace(/['"]$/, ''));
        return selector.nodes[0].nodes;
    },
    '-st-states'(value, decl, diagnostics) {
        if (!value) {
            return {};
        }
        return pseudo_states_1.processPseudoStates(value, decl, diagnostics);
    },
    '-st-extends'(value) {
        const ast = postcss_value_parser_1.default(value);
        const types = [];
        ast.walk((node) => {
            if (node.type === 'function') {
                const args = getNamedArgs(node);
                types.push({
                    symbolName: node.value,
                    args,
                });
                return false;
            }
            else if (node.type === 'word') {
                types.push({
                    symbolName: node.value,
                    args: null,
                });
            }
            return undefined;
        }, false);
        return {
            ast,
            types,
        };
    },
    '-st-named'(value, node, diagnostics) {
        const namedMap = {};
        const keyframesMap = {};
        if (value) {
            handleNamedTokens(postcss_value_parser_1.default(value), { namedMap, keyframesMap }, 'namedMap', node, diagnostics);
        }
        return { namedMap, keyframesMap };
    },
    '-st-mixin'(mixinNode, strategy, diagnostics) {
        const ast = postcss_value_parser_1.default(mixinNode.value);
        const mixins = [];
        function reportWarning(message, options) {
            if (diagnostics) {
                diagnostics.warn(mixinNode, message, options);
            }
        }
        ast.nodes.forEach((node) => {
            const strat = strategy(node.value);
            if (node.type === 'function') {
                mixins.push({
                    type: node.value,
                    options: exports.strategies[strat](node, reportWarning),
                });
            }
            else if (node.type === 'word') {
                mixins.push({
                    type: node.value,
                    options: strat === 'named' ? {} : [],
                });
            }
            else if (node.type === 'string' && diagnostics) {
                diagnostics.error(mixinNode, exports.valueParserWarnings.VALUE_CANNOT_BE_STRING(), {
                    word: mixinNode.value,
                });
            }
        });
        return mixins;
    },
    '-st-partial-mixin'(mixinNode, strategy, diagnostics) {
        return exports.SBTypesParsers['-st-mixin'](mixinNode, strategy, diagnostics).map((mixin) => {
            mixin.partial = true;
            return mixin;
        });
    },
};
function handleNamedTokens(tokens, buckets, key = 'namedMap', node, diagnostics) {
    const { nodes } = tokens;
    for (let i = 0; i < nodes.length; i++) {
        const token = nodes[i];
        if (token.type === 'word') {
            const space = nodes[i + 1];
            const as = nodes[i + 2];
            const spaceAfter = nodes[i + 3];
            const asName = nodes[i + 4];
            if (isImportAs(space, as)) {
                if ((spaceAfter === null || spaceAfter === void 0 ? void 0 : spaceAfter.type) === 'space' && (asName === null || asName === void 0 ? void 0 : asName.type) === 'word') {
                    buckets[key][asName.value] = token.value;
                    i += 4; //ignore next 4 tokens
                }
                else {
                    i += !asName ? 3 : 2;
                    diagnostics.warn(node, exports.valueParserWarnings.INVALID_NAMED_IMPORT_AS(token.value));
                    continue;
                }
            }
            else {
                buckets[key][token.value] = token.value;
            }
        }
        else if (token.type === 'function' && token.value === 'keyframes') {
            if (key === 'keyframesMap') {
                diagnostics.warn(node, exports.valueParserWarnings.INVALID_NESTED_KEYFRAMES(postcss_value_parser_1.default.stringify(token)));
            }
            handleNamedTokens(token, buckets, 'keyframesMap', node, diagnostics);
        }
    }
}
function isImportAs(space, as) {
    return (space === null || space === void 0 ? void 0 : space.type) === 'space' && (as === null || as === void 0 ? void 0 : as.type) === 'word' && (as === null || as === void 0 ? void 0 : as.value) === 'as';
}
function getNamedArgs(node) {
    const args = [];
    if (node.nodes.length) {
        args.push([]);
        node.nodes.forEach((node) => {
            if (node.type === 'div') {
                args.push([]);
            }
            else {
                const { sourceIndex, ...clone } = node;
                args[args.length - 1].push(clone);
            }
        });
    }
    // handle trailing comma
    return args.length && args[args.length - 1].length === 0 ? args.slice(0, -1) : args;
}
exports.getNamedArgs = getNamedArgs;
function getFormatterArgs(node, allowComments = false, _reportWarning, perserveQuotes = false) {
    const argsResult = [];
    let currentArg = '';
    let argIndex = 0;
    for (const currentNode of node.nodes) {
        if (currentNode.type === 'div' && currentNode.value === ',') {
            checkEmptyArg();
            argIndex++;
            argsResult.push(currentArg.trim());
            currentArg = '';
        }
        else if (currentNode.type === 'comment') {
            if (allowComments) {
                currentArg +=
                    currentNode.resolvedValue || postcss_value_parser_1.default.stringify(currentNode);
            }
        }
        else if (currentNode.type === 'string') {
            currentArg += perserveQuotes
                ? postcss_value_parser_1.default.stringify(currentNode)
                : currentNode.value;
        }
        else {
            currentArg += currentNode.resolvedValue || postcss_value_parser_1.default.stringify(currentNode);
        }
    }
    checkEmptyArg();
    argsResult.push(currentArg.trim());
    let i = argsResult.length;
    while (i--) {
        if (argsResult[i] === '') {
            argsResult.pop();
        }
        else {
            return argsResult;
        }
    }
    return argsResult;
    function checkEmptyArg() {
        if (currentArg.trim() === '' && _reportWarning) {
            _reportWarning(`${postcss_value_parser_1.default.stringify(node)}: argument at index ${argIndex} is empty`);
        }
    }
}
exports.getFormatterArgs = getFormatterArgs;
function getStringValue(nodes) {
    return postcss_value_parser_1.default.stringify(nodes, (node) => {
        if (node.resolvedValue !== undefined) {
            return node.resolvedValue;
        }
        else {
            // TODO: warn
            return undefined;
        }
    });
}
exports.getStringValue = getStringValue;
function groupValues(nodes, divType = 'div') {
    const grouped = [];
    let current = [];
    nodes.forEach((n) => {
        if (n.type === divType) {
            grouped.push(current);
            current = [];
        }
        else {
            current.push(n);
        }
    });
    const last = grouped[grouped.length - 1];
    if ((last && last !== current && current.length) || (!last && current.length)) {
        grouped.push(current);
    }
    return grouped;
}
exports.groupValues = groupValues;
exports.strategies = {
    named: (node, reportWarning) => {
        const named = {};
        getNamedArgs(node).forEach((mixinArgsGroup) => {
            const argsDivider = mixinArgsGroup[1];
            if (mixinArgsGroup.length < 3 || (argsDivider && argsDivider.type !== 'space')) {
                if (reportWarning) {
                    const argValue = mixinArgsGroup[0];
                    reportWarning(exports.valueParserWarnings.CSS_MIXIN_FORCE_NAMED_PARAMS(), {
                        word: argValue.value,
                    });
                }
                return;
            }
            named[mixinArgsGroup[0].value] = stringifyParam(mixinArgsGroup.slice(2));
        });
        return named;
    },
    args: (node, reportWarning) => {
        return getFormatterArgs(node, true, reportWarning).map((value) => ({ value }));
    },
};
function stringifyParam(nodes) {
    return postcss_value_parser_1.default.stringify(nodes, (n) => {
        if (n.type === 'function') {
            return postcss_value_parser_1.default.stringify(n);
        }
        else if (n.type === 'div') {
            return null;
        }
        else if (n.type === 'string') {
            return n.value;
        }
        else {
            return undefined;
        }
    });
}
function listOptions(node) {
    return groupValues(node.nodes)
        .map((nodes) => postcss_value_parser_1.default.stringify(nodes, (n) => {
        if (n.type === 'div') {
            return null;
        }
        else if (n.type === 'string') {
            return n.value;
        }
        else {
            return undefined;
        }
    }))
        .filter((x) => typeof x === 'string');
}
exports.listOptions = listOptions;
function validateAllowedNodesUntil(node, i, untilType = 'div', allowed = ['comment']) {
    i = 1;
    let current = node.nodes[i];
    while (current && current.type !== untilType) {
        if (!allowed.includes(current.type)) {
            return false;
        }
        i++;
        current = node.nodes[i];
    }
    return true;
}
exports.validateAllowedNodesUntil = validateAllowedNodesUntil;
//# sourceMappingURL=stylable-value-parsers.js.map