You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
387 lines
14 KiB
387 lines
14 KiB
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
function _export(target, all) {
|
|
for(var name in all)Object.defineProperty(target, name, {
|
|
enumerable: true,
|
|
get: all[name]
|
|
});
|
|
}
|
|
_export(exports, {
|
|
VALID_ANGLE_UNITS: function() {
|
|
return VALID_ANGLE_UNITS;
|
|
},
|
|
VALID_LENGTH_UNITS: function() {
|
|
return VALID_LENGTH_UNITS;
|
|
},
|
|
VALID_TIME_UNITS: function() {
|
|
return VALID_TIME_UNITS;
|
|
},
|
|
normaliseAlphaValue: function() {
|
|
return normaliseAlphaValue;
|
|
},
|
|
normaliseAnglePercentageValue: function() {
|
|
return normaliseAnglePercentageValue;
|
|
},
|
|
normaliseAngleValue: function() {
|
|
return normaliseAngleValue;
|
|
},
|
|
normaliseLengthPercentageValue: function() {
|
|
return normaliseLengthPercentageValue;
|
|
},
|
|
normaliseLengthValue: function() {
|
|
return normaliseLengthValue;
|
|
},
|
|
normaliseNumberPercentageValue: function() {
|
|
return normaliseNumberPercentageValue;
|
|
},
|
|
normaliseNumberValue: function() {
|
|
return normaliseNumberValue;
|
|
},
|
|
normalisePercentageValue: function() {
|
|
return normalisePercentageValue;
|
|
},
|
|
normaliseTimePercentageValue: function() {
|
|
return normaliseTimePercentageValue;
|
|
},
|
|
normaliseTimeValue: function() {
|
|
return normaliseTimeValue;
|
|
},
|
|
normaliseUnionValue: function() {
|
|
return normaliseUnionValue;
|
|
},
|
|
normaliseUnitValue: function() {
|
|
return normaliseUnitValue;
|
|
},
|
|
toNumericValue: function() {
|
|
return toNumericValue;
|
|
},
|
|
toNumericValueAndUnit: function() {
|
|
return toNumericValueAndUnit;
|
|
},
|
|
toStringValue: function() {
|
|
return toStringValue;
|
|
}
|
|
});
|
|
var _object_spread = require("@swc/helpers/_/_object_spread");
|
|
var _to_consumable_array = require("@swc/helpers/_/_to_consumable_array");
|
|
var _lodash = require("lodash");
|
|
var _generateguard = require("./generate-guard");
|
|
var VALID_LENGTH_UNITS = [
|
|
"ch",
|
|
"em",
|
|
"ex",
|
|
"ic",
|
|
"rem",
|
|
"vh",
|
|
"vw",
|
|
"vmax",
|
|
"vmin",
|
|
"vb",
|
|
"vi",
|
|
"cqw",
|
|
"cqh",
|
|
"cqi",
|
|
"cqb",
|
|
"cqmin",
|
|
"cqmax",
|
|
"px",
|
|
"cm",
|
|
"mm",
|
|
"Q",
|
|
"in",
|
|
"pc",
|
|
"pt"
|
|
];
|
|
var VALID_ANGLE_UNITS = [
|
|
"deg",
|
|
"grad",
|
|
"rad",
|
|
"turn"
|
|
];
|
|
var VALID_TIME_UNITS = [
|
|
"s",
|
|
"ms"
|
|
];
|
|
var toStringValue = function(value) {
|
|
if ((0, _lodash.isString)(value)) {
|
|
return value.trim();
|
|
}
|
|
if ((0, _lodash.isFinite)(value)) {
|
|
return String(value);
|
|
}
|
|
return undefined;
|
|
};
|
|
var toNumericValue = function(value) {
|
|
if ((0, _lodash.isFinite)(value)) {
|
|
return Number(value);
|
|
}
|
|
if ((0, _lodash.isString)(value)) {
|
|
var trimmed = value.trim();
|
|
if (trimmed === "") {
|
|
return undefined;
|
|
}
|
|
var maybeNumber = Number(trimmed);
|
|
if (isNaN(maybeNumber)) {
|
|
return undefined;
|
|
}
|
|
return maybeNumber;
|
|
}
|
|
return undefined;
|
|
};
|
|
var toNumericValueAndUnit = function(value, validUnits) {
|
|
var stringValue = toStringValue(value);
|
|
var evaluated = {
|
|
value: undefined,
|
|
unit: undefined
|
|
};
|
|
if ((0, _lodash.isUndefined)(stringValue)) {
|
|
return evaluated;
|
|
}
|
|
if (stringValue === "") {
|
|
return evaluated;
|
|
}
|
|
var strippedStringValue = stringValue.replace(/\s/g, "");
|
|
var safeValidUnits = (0, _lodash.chain)(validUnits).castArray().uniq().filter((0, _generateguard.generateGuard)([
|
|
_lodash.isString,
|
|
function(maybe) {
|
|
return maybe !== "";
|
|
}
|
|
])).value();
|
|
if (safeValidUnits.length > 0) {
|
|
var unitsUnion = safeValidUnits.join("|");
|
|
var unitsMatch = strippedStringValue.match(new RegExp("(?:".concat(unitsUnion, ")$")));
|
|
if ((0, _lodash.isArray)(unitsMatch) && unitsMatch.length === 1) {
|
|
evaluated.unit = unitsMatch[0];
|
|
}
|
|
}
|
|
// Simple numbers without units
|
|
var numberValue = toNumericValue(strippedStringValue);
|
|
if ((0, _lodash.isNumber)(numberValue)) {
|
|
evaluated.value = numberValue;
|
|
return evaluated;
|
|
}
|
|
var unitlessStringValue = (0, _lodash.isString)(evaluated.unit) ? strippedStringValue.replace(new RegExp("".concat(evaluated.unit, "$")), "") : strippedStringValue;
|
|
var unitlessNumberValue = toNumericValue(unitlessStringValue);
|
|
if ((0, _lodash.isNumber)(unitlessNumberValue)) {
|
|
evaluated.value = unitlessNumberValue;
|
|
return evaluated;
|
|
}
|
|
var rescueStringValue = unitlessStringValue.replace(/[^\d.-]/g, "").replace(/\b-/g, "");
|
|
var rescueNumberValue = toNumericValue(rescueStringValue);
|
|
if ((0, _lodash.isNumber)(rescueNumberValue)) {
|
|
evaluated.value = rescueNumberValue;
|
|
return evaluated;
|
|
}
|
|
return evaluated;
|
|
};
|
|
var normaliseUnionValue = function(value, defaultValue, allowedValues) {
|
|
var safeValue = toStringValue(value);
|
|
var safeDefaultValue = toStringValue(defaultValue);
|
|
if ((0, _lodash.isUndefined)(safeValue)) {
|
|
return safeDefaultValue;
|
|
}
|
|
var safeAllowedValues = (0, _lodash.chain)(defaultValue).castArray().concat(allowedValues !== null && allowedValues !== void 0 ? allowedValues : []).uniq().filter(_lodash.isString).map(_lodash.trim).value();
|
|
var matchedIndex = (0, _lodash.chain)(safeAllowedValues).map(_lodash.toLower).indexOf((0, _lodash.toLower)(safeValue)).value();
|
|
if (matchedIndex !== -1) {
|
|
return safeAllowedValues[matchedIndex];
|
|
}
|
|
return safeDefaultValue;
|
|
};
|
|
var isLimit = (0, _generateguard.generateGuard)([
|
|
_lodash.isPlainObject,
|
|
function(maybe) {
|
|
return (0, _lodash.isNumber)((0, _lodash.get)(maybe, "limit"));
|
|
},
|
|
function(maybe) {
|
|
return (0, _lodash.has)(maybe, "inclusive") ? (0, _lodash.isBoolean)((0, _lodash.get)(maybe, "inclusive")) : true;
|
|
},
|
|
function(maybe) {
|
|
return (0, _lodash.has)(maybe, "adjustBy") ? (0, _lodash.isNumber)((0, _lodash.get)(maybe, "adjustBy")) : true;
|
|
}
|
|
]);
|
|
// Not a type guard
|
|
var isVar = function(maybe) {
|
|
return /^var\(\s*--[a-zA-Z0-9-]+\s*(,\s*.+)?\s*\)$/.test(maybe);
|
|
};
|
|
// Not a type guard
|
|
var isCalc = function(maybe) {
|
|
return /^calc\(\s*(?:var\(\s*--[a-zA-Z0-9-]+\s*(,\s*.+)?\s*\)|[0-9]+[a-zA-Z%]*)\s+[*/+-]\s+(?:var\(\s*--[a-zA-Z0-9-]+\s*(,\s*.+)?\s*\)|[0-9]+[a-zA-Z%]*)\s*\)$/.test(maybe);
|
|
};
|
|
var normaliseUnitValue = function(value, defaultValue, options) {
|
|
var safeValue = toStringValue(value);
|
|
var safeDefaultValue = toStringValue(defaultValue);
|
|
var _ref = (0, _lodash.isObject)(options) && (0, _lodash.isPlainObject)(options) ? options : {}, defaultNil = _ref.defaultNil, allowNone = _ref.allowNone, allowVar = _ref.allowVar, allowCalc = _ref.allowCalc, defaultUnit = _ref.defaultUnit, validUnits = _ref.validUnits, disallowValues = _ref.disallowValues, allowDecimal = _ref.allowDecimal, upperLimit = _ref.upperLimit, lowerLimit = _ref.lowerLimit;
|
|
var safeDefaultNil = (0, _lodash.isString)(defaultNil) && (0, _lodash.includes)([
|
|
"0",
|
|
"none",
|
|
""
|
|
], defaultNil) ? defaultNil : "0";
|
|
if ((0, _lodash.isUndefined)(safeValue)) {
|
|
return safeDefaultValue !== null && safeDefaultValue !== void 0 ? safeDefaultValue : safeDefaultNil;
|
|
}
|
|
var safeAllowNone = (0, _lodash.isBoolean)(allowNone) ? allowNone : true;
|
|
if (safeAllowNone && safeValue.toLowerCase() === "none") {
|
|
return "none";
|
|
}
|
|
var safeAllowVar = (0, _lodash.isBoolean)(allowVar) ? allowVar : true;
|
|
// Return a var() if that is allowed - fairly coarse validation
|
|
if (safeValue.startsWith("var(")) {
|
|
return safeAllowVar && isVar(safeValue) ? safeValue : safeDefaultValue !== null && safeDefaultValue !== void 0 ? safeDefaultValue : safeDefaultNil;
|
|
}
|
|
var safeAllowCalc = (0, _lodash.isBoolean)(allowCalc) ? allowCalc : false;
|
|
// Return a calc() if that is allowed - fairly coarse validation
|
|
if (safeValue.startsWith("calc(")) {
|
|
return safeAllowCalc && isCalc(safeValue) ? safeValue : safeDefaultValue !== null && safeDefaultValue !== void 0 ? safeDefaultValue : safeDefaultNil;
|
|
}
|
|
var _toStringValue;
|
|
var safeDefaultUnit = (_toStringValue = toStringValue(defaultUnit)) !== null && _toStringValue !== void 0 ? _toStringValue : "";
|
|
var safeValidUnits = (0, _lodash.chain)(safeDefaultUnit).castArray().concat(validUnits !== null && validUnits !== void 0 ? validUnits : []).filter(_lodash.isString).value();
|
|
// Get the number value and unit from the string
|
|
var _toNumericValueAndUnit = toNumericValueAndUnit(safeValue, safeValidUnits), safeNumberValue = _toNumericValueAndUnit.value, unit = _toNumericValueAndUnit.unit;
|
|
var _ref1;
|
|
var safeUnit = (_ref1 = unit !== null && unit !== void 0 ? unit : defaultUnit) !== null && _ref1 !== void 0 ? _ref1 : "";
|
|
// From here on we are dealing with number values
|
|
if (!(0, _lodash.isNumber)(safeNumberValue)) {
|
|
return safeDefaultValue !== null && safeDefaultValue !== void 0 ? safeDefaultValue : safeDefaultNil;
|
|
}
|
|
var safeDisallowValues = (0, _lodash.chain)(disallowValues).castArray().filter(_lodash.isNumber).value();
|
|
var safeAllowDecimal = (0, _lodash.isBoolean)(allowDecimal) ? allowDecimal : true;
|
|
// Set up an integer value
|
|
var safeIntegerValue = Math.round(safeNumberValue);
|
|
// Check the value isn't disallowed
|
|
// - use integer value if decimals are not allowed
|
|
if ((0, _lodash.includes)(safeDisallowValues, safeAllowDecimal ? safeNumberValue : safeIntegerValue)) {
|
|
return safeDefaultValue !== null && safeDefaultValue !== void 0 ? safeDefaultValue : safeDefaultNil;
|
|
}
|
|
var evaluated = {
|
|
value: safeAllowDecimal ? safeNumberValue : safeIntegerValue,
|
|
unit: safeUnit
|
|
};
|
|
var safeUpperLimit = (0, _lodash.isNumber)(upperLimit) ? {
|
|
limit: upperLimit,
|
|
inclusive: true,
|
|
adjustBy: 1
|
|
} : isLimit(upperLimit) ? {
|
|
limit: upperLimit.limit,
|
|
inclusive: (0, _lodash.isBoolean)(upperLimit.inclusive) ? upperLimit.inclusive : true,
|
|
adjustBy: (0, _lodash.isNumber)(upperLimit.adjustBy) && upperLimit.adjustBy !== 0 ? upperLimit.adjustBy : 1
|
|
} : false;
|
|
// Set the evaluated value within the upper limit
|
|
if (safeUpperLimit) {
|
|
if (safeUpperLimit.inclusive) {
|
|
if (safeNumberValue > safeUpperLimit.limit) {
|
|
evaluated.value = safeUpperLimit.limit;
|
|
}
|
|
} else {
|
|
if (safeNumberValue >= safeUpperLimit.limit) {
|
|
evaluated.value = safeUpperLimit.limit - safeUpperLimit.adjustBy;
|
|
}
|
|
}
|
|
}
|
|
var safeLowerLimit = (0, _lodash.isNumber)(lowerLimit) ? {
|
|
limit: lowerLimit,
|
|
inclusive: true,
|
|
adjustBy: 1
|
|
} : isLimit(lowerLimit) ? {
|
|
limit: lowerLimit.limit,
|
|
inclusive: (0, _lodash.isBoolean)(lowerLimit.inclusive) ? lowerLimit.inclusive : true,
|
|
adjustBy: (0, _lodash.isNumber)(lowerLimit.adjustBy) && lowerLimit.adjustBy !== 0 ? lowerLimit.adjustBy : 1
|
|
} : false;
|
|
// Set the evaluated value within the lower limit
|
|
if (safeLowerLimit) {
|
|
if (safeLowerLimit.inclusive) {
|
|
if (safeNumberValue < safeLowerLimit.limit) {
|
|
evaluated.value = safeLowerLimit.limit;
|
|
}
|
|
} else {
|
|
if (safeNumberValue <= safeLowerLimit.limit) {
|
|
evaluated.value = safeLowerLimit.limit + safeLowerLimit.adjustBy;
|
|
}
|
|
}
|
|
}
|
|
if (evaluated.value === 0 && defaultNil) {
|
|
return defaultNil;
|
|
}
|
|
return "".concat(String(evaluated.value)).concat(evaluated.unit);
|
|
};
|
|
var normaliseAlphaValue = function(value, defaultValue, options) {
|
|
var safeValue = toStringValue(value);
|
|
var safeDefaultValue = toStringValue(defaultValue);
|
|
if ((0, _lodash.isUndefined)(safeValue)) {
|
|
return safeDefaultValue;
|
|
}
|
|
if (safeValue.indexOf("%") !== -1) {
|
|
return normalisePercentageValue(value, defaultValue, _object_spread._({
|
|
lowerLimit: 0,
|
|
upperLimit: 100
|
|
}, options === null || options === void 0 ? void 0 : options.percentage));
|
|
}
|
|
return normaliseNumberValue(value, defaultValue, _object_spread._({
|
|
lowerLimit: 0,
|
|
upperLimit: 1
|
|
}, options === null || options === void 0 ? void 0 : options.number));
|
|
};
|
|
var normaliseAngleValue = function(value, defaultValue, options) {
|
|
return normaliseUnitValue(value, defaultValue, _object_spread._({
|
|
defaultUnit: "deg",
|
|
validUnits: VALID_ANGLE_UNITS
|
|
}, options));
|
|
};
|
|
var normaliseAnglePercentageValue = function(value, defaultValue, options) {
|
|
return normaliseUnitValue(value, defaultValue, _object_spread._({
|
|
defaultUnit: "deg",
|
|
validUnits: _to_consumable_array._(VALID_ANGLE_UNITS).concat([
|
|
"%"
|
|
])
|
|
}, options));
|
|
};
|
|
var normaliseLengthValue = function(value, defaultValue, options) {
|
|
return normaliseUnitValue(value, defaultValue, _object_spread._({
|
|
defaultUnit: "px",
|
|
validUnits: VALID_LENGTH_UNITS
|
|
}, options));
|
|
};
|
|
var normaliseLengthPercentageValue = function(value, defaultValue, options) {
|
|
return normaliseUnitValue(value, defaultValue, _object_spread._({
|
|
defaultUnit: "px",
|
|
validUnits: _to_consumable_array._(VALID_LENGTH_UNITS).concat([
|
|
"%"
|
|
])
|
|
}, options));
|
|
};
|
|
var normaliseNumberValue = function(value, defaultValue, options) {
|
|
return normaliseUnitValue(value, defaultValue, options);
|
|
};
|
|
var normaliseNumberPercentageValue = function(value, defaultValue, options) {
|
|
return normaliseUnitValue(value, defaultValue, _object_spread._({
|
|
validUnits: [
|
|
"",
|
|
"%"
|
|
]
|
|
}, options));
|
|
};
|
|
var normalisePercentageValue = function(value, defaultValue, options) {
|
|
return normaliseUnitValue(value, defaultValue, _object_spread._({
|
|
defaultUnit: "%",
|
|
validUnits: [
|
|
"%"
|
|
]
|
|
}, options));
|
|
};
|
|
var normaliseTimeValue = function(value, defaultValue, options) {
|
|
return normaliseUnitValue(value, defaultValue, _object_spread._({
|
|
defaultUnit: "s",
|
|
validUnits: VALID_TIME_UNITS
|
|
}, options));
|
|
};
|
|
var normaliseTimePercentageValue = function(value, defaultValue, options) {
|
|
return normaliseUnitValue(value, defaultValue, _object_spread._({
|
|
defaultUnit: "s",
|
|
validUnits: _to_consumable_array._(VALID_TIME_UNITS).concat([
|
|
"%"
|
|
])
|
|
}, options));
|
|
};
|