postcss-conditionals-renewed/dist/lib/convert.js

PostCSS plugin that enables @if statements in your CSS

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _cssColorConverter = require('css-color-converter');

var _cssUnitConverter = require('css-unit-converter');

var _cssUnitConverter2 = _interopRequireDefault(_cssUnitConverter);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function convertNodes(left, right) {
    switch (left.type) {
        case 'Value':
            return convertValue(left, right);
        case 'ColorValue':
            return convertColorValue(left, right);
        case 'LengthValue':
        case 'AngleValue':
        case 'TimeValue':
        case 'FrequencyValue':
        case 'ResolutionValue':
            return convertAbsoluteLengthValue(left, right);
        case 'EmValue':
        case 'ExValue':
        case 'ChValue':
        case 'RemValue':
        case 'VhValue':
        case 'VwValue':
        case 'VminValue':
        case 'VmaxValue':
        case 'PercentageValue':
            return convertRelativeLengthValue(left, right);
        default:
            return { left, right };
    }
}

function convertValue(left, right) {
    if (right.type === 'Value') return { left, right };

    var nodes = convertNodes(right, left);
    return {
        left: nodes.right,
        right: nodes.left
    };
}

function parseColor(node) {
    var color = (0, _cssColorConverter.fromString)(node.value);

    if (color) {
        return color.toHexString();
    }

    return null;
}

function convertColorValue(left, right) {
    left.value = parseColor(left);
    if (right.type === 'Value') {
        right = {
            type: 'ColorValue',
            value: (0, _cssColorConverter.fromRgb)([right.value, right.value, right.value]).toHexString()
        };
    } else if (right.type === 'ColorValue') {
        right.value = parseColor(right);
    }

    return { left, right };
}

function convertAbsoluteLengthValue(left, right) {
    switch (right.type) {
        case left.type:
            {
                right = {
                    type: left.type,
                    value: (0, _cssUnitConverter2.default)(right.value, right.unit, left.unit),
                    unit: left.unit
                };
                break;
            }
        case 'Value':
            {
                right = {
                    type: left.type,
                    value: right.value,
                    unit: left.unit
                };
                break;
            }
    }
    return { left, right };
}

function convertRelativeLengthValue(left, right) {
    if (right.type === 'Value') {
        right = {
            type: left.type,
            value: right.value,
            unit: left.unit
        };
    }
    return { left, right };
}

exports.default = convertNodes;
module.exports = exports.default;