Files
OpenMaopaoya/frontend-uni/node_modules/@dcloudio/uni-nvue-styler/dist/uni-nvue-styler.es.js
T

1377 lines
48 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { hyphenate, capitalize } from '@vue/shared';
function createDecl(prop, value, important, raws, source) {
const decl = {
type: 'decl',
prop,
value: value.toString(),
raws,
source,
};
if (important) {
decl.important = true;
}
return decl;
}
const NUM_REGEXP = /^[-]?\d*\.?\d+$/;
const LENGTH_REGEXP = /^[-+]?\d*\.?\d+(\S*)$/;
const SUPPORT_CSS_UNIT = ['px', 'pt', 'wx', 'upx', 'rpx'];
const DOM2_CSS_DOCS_BASE_URL = 'https://doc.dcloud.net.cn/uni-app-x/css';
function getDom2PropertyDocsUrl(property) {
return `${DOM2_CSS_DOCS_BASE_URL}/${hyphenateStyleProperty(property)}.html#suggestion`;
}
function appendDom2Docs(reason, url) {
return url ? `${reason} 详见:${url}` : reason;
}
const isNumber = (val) => typeof val === 'number';
const cacheStringFunction = (fn) => {
const cache = Object.create(null);
return ((str) => {
const hit = cache[str];
return hit || (cache[str] = fn(str));
});
};
const hyphenateRE = /([A-Z])/g;
const hyphenateStyleProperty = cacheStringFunction((str) => str
.replace(hyphenateRE, (_, m) => {
if (typeof m === 'string') {
return '-' + m.toLowerCase();
}
return m;
})
.toLowerCase());
function validReason(k, v) {
return ('ERROR: property value `' +
v +
'` is not valid for `' +
hyphenateStyleProperty(k) +
'`');
}
function defaultValueReason(k, v) {
return ('NOTE: property value `' +
v +
'` is the DEFAULT value for `' +
hyphenateStyleProperty(k) +
'` (could be removed)');
}
function supportedEnumReason(k, v, items) {
const reason = 'ERROR: property value `' +
v +
'` is not supported for `' +
hyphenateStyleProperty(k) +
'`';
return items.length
? reason + ' (supported values are: `' + items.join('`|`') + '`)'
: reason;
}
function supportedValueWithTipsReason(k, v, tips) {
return ('ERROR: property value `' +
v +
'` is not supported for `' +
hyphenateStyleProperty(k) +
'` ' +
tips);
}
function supportedUnitWithAutofixedReason(unit, v, result) {
return ('NOTE: unit `' +
unit +
'` is not supported and property value `' +
v +
'` is autofixed to `' +
result +
'`');
}
/**
* css value 分割多值,兼容包含括号的 css 方法,比如 var/env/calc() 等
*/
function splitValues(value) {
const trimmedValue = value.trim();
if (!trimmedValue.includes('(')) {
return trimmedValue.split(/\s+/);
}
const parts = [];
let current = '';
let depth = 0;
for (let i = 0; i < trimmedValue.length; i++) {
const char = trimmedValue[i];
if (char === '(') {
depth++;
current += char;
}
else if (char === ')') {
if (depth > 0) {
depth--;
}
current += char;
}
else if (/\s/.test(char)) {
if (depth === 0) {
if (current) {
parts.push(current);
current = '';
}
}
else {
// 多个空格处理一个
if (current.length > 0 && !/\s$/.test(current)) {
current += ' ';
}
}
}
else {
current += char;
}
}
if (current) {
parts.push(current);
}
return parts;
}
function isSingleCssVarValue(value) {
const trimmedValue = value.trim();
if (splitValues(trimmedValue).length !== 1 || !/^var\(/i.test(trimmedValue)) {
return false;
}
let depth = 0;
for (let i = 0; i < trimmedValue.length; i++) {
const char = trimmedValue[i];
if (char === '(') {
depth++;
}
else if (char === ')') {
if (depth === 0) {
return false;
}
depth--;
if (depth === 0 && trimmedValue.slice(i + 1).trim()) {
return false;
}
}
}
return depth === 0;
}
function tryExpandSingleValueVarShorthand(decl, props, value, dom2) {
// 只在 dom2 运行时兜底展开,避免影响其它平台现有行为。
if (!dom2) {
return null;
}
// 当整个简写值只有一个 var() 时,无法静态判断它属于哪个子属性,
// 这里直接复制到每个长属性,交给运行时再解析。
if (!isSingleCssVarValue(value)) {
return null;
}
return expandShorthand(decl, props, value);
}
function expandShorthand(decl, props, value) {
const { important, raws, source } = decl;
return props.map((prop) => createDecl(prop, value, important, raws, source));
}
const backgroundColor = 'backgroundColor';
const backgroundImage = 'backgroundImage';
function isCssVarValue$3(value) {
return /^var\(/i.test(value);
}
function isBackgroundImageValue(value) {
return value === 'none' || /^linear-gradient(.+)$/.test(value);
}
function isBackgroundColorValue(value) {
return (!isCssVarValue$3(value) &&
!isBackgroundImageValue(value) &&
(/^#?\S+$/.test(value) || /^rgba?(.+)$/.test(value)));
}
const handleTransformBackground = (decl, dom2) => {
let { value, important, raws, source } = decl;
value = value.trim();
const singleVarResult = tryExpandSingleValueVarShorthand(decl, [backgroundImage, backgroundColor], value, dom2);
if (singleVarResult) {
return singleVarResult;
}
if (dom2) {
const values = splitValues(value);
if (values.length === 2) {
const variableIndex = values.findIndex(isCssVarValue$3);
const otherIndex = variableIndex === 0 ? 1 : 0;
if (variableIndex >= 0 &&
!isCssVarValue$3(values[otherIndex]) &&
(isBackgroundImageValue(values[otherIndex]) ||
isBackgroundColorValue(values[otherIndex]))) {
const variableValue = values[variableIndex];
const otherValue = values[otherIndex];
const variableIsImage = isBackgroundColorValue(otherValue);
return [
createDecl(backgroundImage, variableIsImage ? variableValue : otherValue, important, raws, source),
createDecl(backgroundColor, variableIsImage ? otherValue : variableValue, important, raws, source),
];
}
}
}
if (value === 'none') {
return [
createDecl(backgroundImage, 'none', important, raws, source),
createDecl(backgroundColor, 'transparent', important, raws, source),
];
}
if (/^#?\S+$/.test(value) || /^rgba?(.+)$/.test(value)) {
return [
createDecl(backgroundImage, 'none', important, raws, source),
createDecl(backgroundColor, value, important, raws, source),
];
}
else if (/^linear-gradient(.+)$/.test(value)) {
return [
createDecl(backgroundImage, value, important, raws, source),
createDecl(backgroundColor, 'transparent', important, raws, source),
];
}
else if (value == '') {
return [
createDecl(backgroundImage, 'none', important, raws, source),
createDecl(backgroundColor, 'transparent', important, raws, source),
];
}
return dom2 && /\bvar\(/i.test(value)
? expandShorthand(decl, [backgroundImage, backgroundColor], value)
: [decl];
};
const handleTransformBackgroundNvue = (decl) => {
const { value, important, raws, source } = decl;
if (/^#?\S+$/.test(value) || /^rgba?(.+)$/.test(value)) {
return [createDecl(backgroundColor, value, important, raws, source)];
}
else if (/^linear-gradient(.+)$/.test(value)) {
return [createDecl(backgroundImage, value, important, raws, source)];
}
else if (value == '') {
return [decl];
}
return [decl];
};
function createTransformBackground(options) {
return (decl) => {
// nvue 平台维持原有逻辑不变
const isUvuePlatform = options.type === 'uvue';
if (isUvuePlatform) {
return handleTransformBackground(decl, !!options.dom2);
}
else {
return handleTransformBackgroundNvue(decl);
}
};
}
const borderTop = 'borderTop';
const borderRight = 'borderRight';
const borderBottom = 'borderBottom';
const borderLeft = 'borderLeft';
const transformBorderColor = (decl) => {
let { prop, value, important, raws, source } = decl;
value = value.trim();
const _property_split = hyphenate(prop).split('-');
let property = _property_split[_property_split.length - 1];
{
property = capitalize(property);
}
const splitResult = splitValues(value); // 1pt
switch (splitResult.length) {
case 1:
if (_property_split.length === 3) {
// border-top-width
return [decl];
}
// border-width
splitResult.push(splitResult[0], splitResult[0], splitResult[0]);
break;
case 2:
splitResult.push(splitResult[0], splitResult[1]);
break;
case 3:
splitResult.push(splitResult[1]);
break;
}
return [
createDecl(borderTop + property, splitResult[0], important, raws, source),
createDecl(borderRight + property, splitResult[1], important, raws, source),
createDecl(borderBottom + property, splitResult[2], important, raws, source),
createDecl(borderLeft + property, splitResult[3], important, raws, source),
];
};
const transformBorderColorNvue = (decl) => {
let { prop, value, important, raws, source } = decl;
value = value.trim();
let property = hyphenate(prop).split('-')[1];
{
property = capitalize(property);
}
const splitResult = value.replace(/\s*,\s*/g, ',').split(/\s+/);
switch (splitResult.length) {
case 1:
return [decl];
case 2:
splitResult.push(splitResult[0], splitResult[1]);
break;
case 3:
splitResult.push(splitResult[1]);
break;
}
return [
createDecl(borderTop + property, splitResult[0], important, raws, source),
createDecl(borderRight + property, splitResult[1], important, raws, source),
createDecl(borderBottom + property, splitResult[2], important, raws, source),
createDecl(borderLeft + property, splitResult[3], important, raws, source),
];
};
const transformBorderStyle = transformBorderColor;
const transformBorderStyleNvue = transformBorderColorNvue;
const transformBorderWidth = transformBorderColor;
const transformBorderWidthNvue = transformBorderColorNvue;
const borderWidth = 'Width';
const borderStyle = 'Style';
const borderColor = 'Color';
const BORDER_WIDTH_REGEXP = /^(?:[\d.]+\S*|thin|medium|thick)$/;
const BORDER_CALC_WIDTH_REGEXP = /^calc\(.+\)$/i;
// 这里按完整 CSS line-style 识别,后续再交给 border-*-style 的既有校验逻辑报精确错误。
const BORDER_STYLE_REGEXP = /^(?:none|hidden|dotted|dashed|solid|double|groove|ridge|inset|outset)$/;
function createBorderVarOrderWarning(prop, value) {
return supportedValueWithTipsReason(prop, value, '(border shorthand with CSS variables must follow `width style color`, for example: `1px solid var(--color, #999999)`)');
}
function isCssVarValue$2(value) {
return value.startsWith('var(');
}
function isBorderWidthValue(value, dom2) {
return (isCssVarValue$2(value) ||
BORDER_WIDTH_REGEXP.test(value) ||
(dom2 && BORDER_CALC_WIDTH_REGEXP.test(value)));
}
function isBorderStyleValue(value) {
return isCssVarValue$2(value) || BORDER_STYLE_REGEXP.test(value);
}
function isBorderColorValue(value, dom2) {
return (isCssVarValue$2(value) ||
(!isBorderWidthValue(value, dom2) && !BORDER_STYLE_REGEXP.test(value)));
}
function createTransformBorder(options) {
return (decl, onWarning) => {
const { prop, value, important, raws, source } = decl;
const dom2 = !!options.dom2;
const singleVarResult = tryExpandSingleValueVarShorthand(decl, [prop + borderWidth, prop + borderStyle, prop + borderColor], value, dom2);
// 单个 var() 无法提前判断是 width/style/color,dom2 下先平铺后继续展开。
if (singleVarResult) {
return [
...transformBorderWidth(singleVarResult[0]),
...transformBorderStyle(singleVarResult[1]),
...transformBorderColor(singleVarResult[2]),
];
}
let splitResult = splitValues(value);
const havVar = splitResult.some((str) => str.startsWith('var('));
let result = [];
// 包含 var 时按位置解析,避免把 style 误判成 color
if (havVar) {
if (splitResult.length > 3 ||
(splitResult.length === 3 &&
(!isBorderWidthValue(splitResult[0], dom2) ||
!isBorderStyleValue(splitResult[1]) ||
!isBorderColorValue(splitResult[2], dom2)))) {
onWarning?.(createBorderVarOrderWarning(prop, value));
return [];
}
result = splitResult;
splitResult = [];
}
else {
result = [
(str) => isBorderWidthValue(str, dom2),
(str) => BORDER_STYLE_REGEXP.test(str),
(str) => /\S+/.test(str),
].map((matches) => {
const index = splitResult.findIndex(matches);
return index < 0 ? null : splitResult.splice(index, 1)[0];
});
}
if (splitResult.length > 0 && value != '') {
return [decl];
}
const defaultWidth = (str) => {
if (str != null) {
return str.trim();
}
return 'medium';
};
const defaultStyle = (str) => {
if (str != null) {
return str.trim();
}
return 'none';
};
const defaultColor = (str) => {
if (str != null) {
return str.trim();
}
return '#000000';
};
return [
...transformBorderWidth(createDecl(prop + borderWidth, defaultWidth(result[0]), important, raws, source)),
...transformBorderStyle(createDecl(prop + borderStyle, defaultStyle(result[1]), important, raws, source)),
...transformBorderColor(createDecl(prop + borderColor, defaultColor(result[2]), important, raws, source)),
];
};
}
/**
* nvue 逻辑不变
*/
function createTransformBorderNvue(options) {
return (decl) => {
let { prop, value, important, raws, source } = decl;
value = value.trim();
const splitResult = value.replace(/\s*,\s*/g, ',').split(/\s+/);
const result = [
/^[\d\.]+\S*|^(thin|medium|thick)$/,
/^(solid|dashed|dotted|none)$/,
/\S+/,
].map((item) => {
const index = splitResult.findIndex((str) => item.test(str));
return index < 0 ? null : splitResult.splice(index, 1)[0];
});
if (splitResult.length) {
return [decl];
}
return [
createDecl(prop + borderWidth, (result[0] || '0').trim(), important, raws, source),
createDecl(prop + borderStyle, (result[1] || 'solid').trim(), important, raws, source),
createDecl(prop + borderColor, (result[2] || '#000000').trim(), important, raws, source),
];
};
}
const borderTopLeftRadius = 'borderTopLeftRadius';
const borderTopRightRadius = 'borderTopRightRadius';
const borderBottomRightRadius = 'borderBottomRightRadius';
const borderBottomLeftRadius = 'borderBottomLeftRadius';
const transformBorderRadius = (decl) => {
let { value, important, raws, source } = decl;
value = value.trim();
const splitResult = splitValues(value);
if (value.includes('/')) {
return [decl];
}
switch (splitResult.length) {
case 1:
splitResult.push(splitResult[0], splitResult[0], splitResult[0]);
break;
case 2:
splitResult.push(splitResult[0], splitResult[1]);
break;
case 3:
splitResult.push(splitResult[1]);
break;
}
return [
createDecl(borderTopLeftRadius, splitResult[0], important, raws, source),
createDecl(borderTopRightRadius, splitResult[1], important, raws, source),
createDecl(borderBottomRightRadius, splitResult[2], important, raws, source),
createDecl(borderBottomLeftRadius, splitResult[3], important, raws, source),
];
};
const transformBorderRadiusNvue = (decl) => {
let { value, important, raws, source } = decl;
value = value.trim();
const splitResult = value.split(/\s+/);
if (value.includes('/')) {
return [decl];
}
// const isUvuePlatform = options.type === 'uvue'
switch (splitResult.length) {
case 1:
return [decl];
case 2:
splitResult.push(splitResult[0], splitResult[1]);
break;
case 3:
splitResult.push(splitResult[1]);
break;
}
return [
createDecl(borderTopLeftRadius, splitResult[0], important, raws, source),
createDecl(borderTopRightRadius, splitResult[1], important, raws, source),
createDecl(borderBottomRightRadius, splitResult[2], important, raws, source),
createDecl(borderBottomLeftRadius, splitResult[3], important, raws, source),
];
};
const flexDirection = 'flexDirection';
const flexWrap = 'flexWrap';
function transformFlexFlowDecl(decl, dom2) {
let { value, important, raws, source } = decl;
value = value.trim();
const splitResult = splitValues(value);
const singleVarResult = tryExpandSingleValueVarShorthand(decl, [flexDirection, flexWrap], value, dom2);
// 单个 var() 无法提前判断是 direction 还是 wrap,dom2 下直接平铺。
if (singleVarResult) {
return singleVarResult;
}
const matchers = [
/^(column|column-reverse|row|row-reverse)$/,
/^(nowrap|wrap|wrap-reverse)$/,
];
const result = matchers.map((item) => {
const index = splitResult.findIndex((str) => item.test(str));
return index < 0 ? null : splitResult.splice(index, 1)[0];
});
if (dom2 &&
splitResult.length === 1 &&
/^var\(/i.test(splitResult[0]) &&
(result[0] === null || result[1] === null)) {
result[result[0] === null ? 0 : 1] = splitResult.pop();
}
if (splitResult.length) {
return dom2 && /\bvar\(/i.test(value)
? expandShorthand(decl, [flexDirection, flexWrap], value)
: [decl];
}
return [
createDecl(flexDirection, result[0] || 'column', important, raws, source),
createDecl(flexWrap, result[1] || 'nowrap', important, raws, source),
];
}
function createTransformFlexFlow(dom2) {
return (decl) => transformFlexFlowDecl(decl, dom2);
}
const top = 'Top';
const right = 'Right';
const bottom = 'Bottom';
const left = 'Left';
const createTransformBox = (type) => {
return (decl) => {
const { value, important, raws, source } = decl;
const splitResult = splitValues(value);
switch (splitResult.length) {
case 1:
splitResult.push(splitResult[0], splitResult[0], splitResult[0]);
break;
case 2:
splitResult.push(splitResult[0], splitResult[1]);
break;
case 3:
splitResult.push(splitResult[1]);
break;
}
return [
createDecl(type + top, splitResult[0], important, raws, source),
createDecl(type + right, splitResult[1], important, raws, source),
createDecl(type + bottom, splitResult[2], important, raws, source),
createDecl(type + left, splitResult[3], important, raws, source),
];
};
};
const transformMargin = createTransformBox('margin');
const transformPadding = createTransformBox('padding');
const transitionProperty = 'transitionProperty';
const transitionDuration = 'transitionDuration';
const transitionTimingFunction = 'transitionTimingFunction';
const transitionDelay = 'transitionDelay';
const transitionLonghands = [
transitionProperty,
transitionDuration,
transitionTimingFunction,
transitionDelay,
];
const TRANSITION_TIME_REGEXP = /^-?(?:\d+(?:\.\d+)?|\.\d+)(?:ms|s)$/;
const TRANSITION_DURATION_REGEXP = /^(?:\d+(?:\.\d+)?|\.\d+)(?:ms|s)$/;
const TRANSITION_SIGNED_TIME_REGEXP = /^[+-](?:\d+(?:\.\d+)?|\.\d+)(?:ms|s)$/;
const TRANSITION_TIMING_FUNCTION_REGEXP = /^(?:linear|ease(?:-in-out|-in|-out)?|cubic-bezier\(\s*-?(?:\d+(?:\.\d+)?|\.\d+)\s*,\s*-?(?:\d+(?:\.\d+)?|\.\d+)\s*,\s*-?(?:\d+(?:\.\d+)?|\.\d+)\s*,\s*-?(?:\d+(?:\.\d+)?|\.\d+)\s*\))$/i;
function isCssVarValue$1(value) {
return /^var\(/i.test(value);
}
function containsCssVar(value) {
return /\bvar\(/i.test(value);
}
function isTransitionTimingFunction(value) {
return TRANSITION_TIMING_FUNCTION_REGEXP.test(value);
}
function parseTransitionItem(value) {
const tokens = splitValues(value);
if (!tokens.length) {
return null;
}
const result = {};
let hasProperty = false;
let hasDuration = false;
let hasTimingFunction = false;
let hasDelay = false;
for (let i = 0; i < tokens.length; i++) {
const token = tokens[i];
if (isTransitionTimingFunction(token)) {
if (hasTimingFunction) {
return null;
}
result.timingFunction = token.toLowerCase();
hasTimingFunction = true;
continue;
}
if (TRANSITION_TIME_REGEXP.test(token)) {
if (!hasDuration) {
// transition-duration 不允许负值,负时间只能作为 delay。
if (token[0] === '-') {
return null;
}
result.duration = token;
hasDuration = true;
}
else if (!hasDelay) {
result.delay = token;
hasDelay = true;
}
else {
return null;
}
continue;
}
if (TRANSITION_SIGNED_TIME_REGEXP.test(token)) {
return null;
}
if (!hasProperty) {
result.property = token;
hasProperty = true;
continue;
}
return null;
}
return result;
}
function tryTransformTransitionNestedVariable(decl, dom2) {
if (!dom2) {
return null;
}
const values = splitValues(decl.value);
if (values.length < 2 ||
values.length > 4 ||
!values.some(containsCssVar) ||
values.some(isCssVarValue$1) ||
TRANSITION_TIME_REGEXP.test(values[0]) ||
!TRANSITION_DURATION_REGEXP.test(values[1]) ||
(values[3] && !TRANSITION_TIME_REGEXP.test(values[3]))) {
return null;
}
const { important, raws, source } = decl;
return values.map((value, index) => createDecl(transitionLonghands[index], value, important, raws, source));
}
function transformTransitionDecl(decl, dom2) {
let { value, important, raws, source } = decl;
value = value.trim();
if (TRANSITION_DURATION_REGEXP.test(value)) {
return [createDecl(transitionDuration, value, important, raws, source)];
}
const singleVarResult = tryExpandSingleValueVarShorthand(decl, transitionLonghands, value, dom2);
if (singleVarResult) {
return singleVarResult;
}
const variableResult = tryTransformTransitionNestedVariable(decl, dom2);
if (variableResult) {
return variableResult;
}
if (dom2 && /\bvar\(/i.test(value)) {
return expandShorthand(decl, transitionLonghands, value);
}
const parsed = parseTransitionItem(value);
if (!parsed) {
return [];
}
const result = [];
if (parsed.property !== undefined) {
result.push(createDecl(transitionProperty, parsed.property, important, raws, source));
}
if (parsed.duration !== undefined) {
result.push(createDecl(transitionDuration, parsed.duration, important, raws, source));
}
if (parsed.timingFunction !== undefined) {
result.push(createDecl(transitionTimingFunction, parsed.timingFunction, important, raws, source));
}
if (parsed.delay !== undefined) {
result.push(createDecl(transitionDelay, parsed.delay, important, raws, source));
}
return result;
}
function createTransformTransition(dom2) {
return (decl) => transformTransitionDecl(decl, dom2);
}
const flexGrow = 'flexGrow';
const flexShrink = 'flexShrink';
const flexBasis = 'flexBasis';
function isCssVarValue(value) {
return /^var\(/i.test(value);
}
function transformFlexDecl(decl, dom2) {
let { value, important, raws, source } = decl;
value = value.trim();
const result = [];
const splitResult = splitValues(value);
const singleVarResult = tryExpandSingleValueVarShorthand(decl, [flexGrow, flexShrink, flexBasis], value, dom2);
// 单个 var() 无法提前拆出 grow/shrink/basis,dom2 下按完整简写平铺。
if (singleVarResult) {
return singleVarResult;
}
const variableResult = dom2 && /\bvar\(/i.test(value)
? expandShorthand(decl, [flexGrow, flexShrink, flexBasis], value)
: null;
// 是否 flex-grow 的有效值 <number [0,∞]>
const isFlexGrowValid = (v) => isNumber(Number(v)) && !Number.isNaN(Number(v));
const isFlexShrinkValid = (v) => isNumber(Number(v)) && !Number.isNaN(Number(v)) && Number(v) >= 0;
const isFlexBasisValid = (v) => typeof v === 'string' && v.trim() !== '';
if (splitResult.length === 1) {
// 关键字处理
if (value === 'none') {
result.push(createDecl(flexGrow, '0', important, raws, source), createDecl(flexShrink, '0', important, raws, source), createDecl(flexBasis, 'auto', important, raws, source));
return result;
}
if (value === 'auto') {
result.push(createDecl(flexGrow, '1', important, raws, source), createDecl(flexShrink, '1', important, raws, source), createDecl(flexBasis, 'auto', important, raws, source));
return result;
}
if (value === 'initial') {
result.push(createDecl(flexGrow, '0', important, raws, source), createDecl(flexShrink, '1', important, raws, source), createDecl(flexBasis, 'auto', important, raws, source));
return result;
}
const v = splitResult[0];
// number 视为 flex-grow
if (isFlexGrowValid(v)) {
if (Number(v) < 0) {
return [];
}
result.push(createDecl(flexGrow, v, important, raws, source), createDecl(flexShrink, '1', important, raws, source), createDecl(flexBasis, '0%', important, raws, source));
return result;
}
else if (isFlexBasisValid(v)) {
result.push(createDecl(flexGrow, '1', important, raws, source), createDecl(flexShrink, '1', important, raws, source), createDecl(flexBasis, v, important, raws, source));
return result;
}
else {
return [decl];
}
}
else if (splitResult.length === 2) {
const [v1, v2] = splitResult;
if (isFlexGrowValid(v1) || (dom2 && isCssVarValue(v1))) {
if (isFlexShrinkValid(v2)) {
// flex: 1 2 => 1 2 0%
result.push(createDecl(flexGrow, v1, important, raws, source), createDecl(flexShrink, v2, important, raws, source), createDecl(flexBasis, '0%', important, raws, source));
return result;
}
else {
if (dom2 && isCssVarValue(v2)) {
return variableResult || [decl];
}
// flex: 1 100px => 1 1 100px
result.push(createDecl(flexGrow, v1, important, raws, source), createDecl(flexShrink, '1', important, raws, source), createDecl(flexBasis, v2, important, raws, source));
return result;
}
}
else {
return variableResult || [decl];
}
}
else if (splitResult.length === 3) {
const [v1, v2, v3] = splitResult;
if ((isFlexGrowValid(v1) || (dom2 && isCssVarValue(v1))) &&
(isFlexShrinkValid(v2) || (dom2 && isCssVarValue(v2)))) {
result.push(createDecl(flexGrow, v1, important, raws, source), createDecl(flexShrink, v2, important, raws, source), createDecl(flexBasis, v3, important, raws, source));
return result;
}
else {
// fallback
return variableResult || [decl];
}
}
// 其它情况,原样返回
return variableResult || [decl];
}
function createTransformFlex(dom2) {
return (decl) => transformFlexDecl(decl, dom2);
}
function createEnumNormalize(items) {
return (v) => {
const index = items.indexOf(v);
if (index > 0) {
return { value: v };
}
if (index === 0) {
return {
value: v,
reason: function reason(k, v, result) {
return defaultValueReason(k, v);
},
};
}
return {
value: null,
reason: function reason(k, v, result) {
return supportedEnumReason(k, v, items);
},
};
};
}
const normalizeTimingFunction = (v) => {
v = (v || '').toString();
if (v.match(/^(?:linear|ease|ease-in|ease-out|ease-in-out)$/)) {
return { value: v };
}
let match;
if ((match = v.match(/^cubic-bezier\(\s*(.*)\s*,\s*(.*)\s*,\s*(.*)\s*,\s*(.*)\s*\)$/))) {
if (match[1].match(NUM_REGEXP) &&
match[2].match(NUM_REGEXP) &&
match[3].match(NUM_REGEXP) &&
match[4].match(NUM_REGEXP)) {
const ret = [
parseFloat(match[1]),
parseFloat(match[2]),
parseFloat(match[3]),
parseFloat(match[4]),
].join(',');
return { value: 'cubic-bezier(' + ret + ')' };
}
}
return {
value: null,
reason(k, v, result) {
return supportedEnumReason(k, v, [
'linear',
'ease',
'ease-in',
'ease-out',
'ease-in-out',
'cubic-bezier(n,n,n,n)',
]);
},
};
};
const KEYFRAMES_NAME_RE = /^-?[A-Za-z_][A-Za-z0-9_-]*$/;
const ANIMATION_NUMBER_RE = /^[+-]?\d*\.?\d+$/;
const MAX_F32_VALUE = 3.4028234663852886e38;
const RESERVED_KEYFRAMES_NAMES = new Set([
'default',
'inherit',
'initial',
'none',
'revert',
'revert-layer',
'unset',
]);
function normalizeAnimationDecimal(value) {
const negative = value[0] === '-';
const unsigned = value.replace(/^[+-]/, '');
const [integer = '', fraction = ''] = unsigned.split('.');
const normalizedInteger = integer.replace(/^0+(?=\d)/, '') || '0';
const normalizedFraction = fraction.replace(/0+$/, '');
const normalized = normalizedFraction
? `${normalizedInteger}.${normalizedFraction}`
: normalizedInteger;
return negative && normalized !== '0' ? `-${normalized}` : normalized;
}
function splitAnimationList(value) {
const result = [];
let start = 0;
let depth = 0;
for (let i = 0; i < value.length; i++) {
const char = value[i];
if (char === '(') {
depth++;
}
else if (char === ')') {
if (depth === 0) {
return null;
}
depth--;
}
else if (char === ',' && depth === 0) {
const item = value.slice(start, i).trim();
if (!item) {
return null;
}
result.push(item);
start = i + 1;
}
}
if (depth !== 0) {
return null;
}
const item = value.slice(start).trim();
if (!item) {
return null;
}
result.push(item);
return result;
}
function createAnimationTimeNormalize(allowNegative) {
return (v) => {
const value = (v || '').toString().toLowerCase();
const match = value.match(/^([+-]?(?:\d+(?:\.\d+)?|\.\d+))(ms|s)$/);
if (match && (allowNegative || value[0] !== '-')) {
const milliseconds = Number(match[1]) * (match[2] === 's' ? 1000 : 1);
if (Number.isFinite(milliseconds) &&
Math.abs(milliseconds) <= MAX_F32_VALUE) {
return { value };
}
}
return {
value: null,
reason(k, v) {
return supportedEnumReason(k, v, [
allowNegative ? 'time' : 'non-negative time',
]);
},
};
};
}
const normalizeAnimationNameItem = (v) => {
const value = (v || '').toString();
const lowerValue = value.toLowerCase();
if (lowerValue === 'none') {
return { value: 'none' };
}
if (KEYFRAMES_NAME_RE.test(value) &&
!RESERVED_KEYFRAMES_NAMES.has(lowerValue)) {
return { value };
}
return {
value: null,
reason: validReason,
};
};
const normalizeAnimationIterationCountItem = (v) => {
const value = (v || '').toString().toLowerCase();
if (value === 'infinite') {
return { value };
}
const count = Number(value);
if (ANIMATION_NUMBER_RE.test(value) && Number.isFinite(count) && count >= 0) {
const normalizedValue = normalizeAnimationDecimal(value);
return {
value: normalizedValue === count.toString() ? count : normalizedValue,
};
}
return {
value: null,
reason(k, v) {
return supportedEnumReason(k, v, ['non-negative number', 'infinite']);
},
};
};
function createAnimationKeywordNormalize(items) {
const normalize = createEnumNormalize(items);
return (v, options) => normalize((v || '').toString().toLowerCase(), options);
}
const normalizeAnimationDelayItem = createAnimationTimeNormalize(true);
const normalizeAnimationDirectionItem = createAnimationKeywordNormalize([
'normal',
'reverse',
'alternate',
'alternate-reverse',
]);
const normalizeAnimationDurationItem = createAnimationTimeNormalize(false);
const normalizeAnimationFillModeItem = createAnimationKeywordNormalize([
'none',
'forwards',
'backwards',
'both',
]);
const normalizeAnimationPlayStateItem = createAnimationKeywordNormalize([
'running',
'paused',
]);
const normalizeAnimationTimingFunctionItem = (v, options) => {
const value = (v || '').toString().toLowerCase();
const result = normalizeTimingFunction(value);
if (typeof result.value === 'string' &&
result.value.startsWith('cubic-bezier(')) {
const values = value
.slice(13, -1)
.split(',')
.map((item) => item.trim());
const numbers = values.map(Number);
if (numbers.some((value) => !Number.isFinite(value) || Math.abs(value) > MAX_F32_VALUE)) {
return normalizeTimingFunction('');
}
result.value = `cubic-bezier(${values
.map(normalizeAnimationDecimal)
.join(',')})`;
}
return result;
};
function isValidValue(normalize, value) {
return normalize(value, {}).value !== null;
}
function parseSingleAnimation(value) {
const tokens = splitValues(value);
if (!tokens.length) {
return null;
}
const result = {
name: 'none',
duration: '0s',
delay: '0s',
timingFunction: 'ease',
iterationCount: '1',
direction: 'normal',
fillMode: 'forwards',
playState: 'running',
};
let hasDuration = false;
let hasDelay = false;
let hasTimingFunction = false;
let hasIterationCount = false;
let hasDirection = false;
let hasFillMode = false;
let hasPlayState = false;
let hasName = false;
let noneCount = 0;
for (let i = 0; i < tokens.length; i++) {
const token = tokens[i];
const keyword = token.toLowerCase();
if (keyword === 'none') {
noneCount++;
continue;
}
if (isValidValue(normalizeAnimationDelayItem, keyword)) {
if (!hasDuration) {
if (!isValidValue(normalizeAnimationDurationItem, keyword)) {
return null;
}
result.duration = keyword;
hasDuration = true;
}
else if (!hasDelay) {
result.delay = keyword;
hasDelay = true;
}
else {
return null;
}
continue;
}
if (!hasTimingFunction &&
isValidValue(normalizeAnimationTimingFunctionItem, keyword)) {
result.timingFunction = keyword;
hasTimingFunction = true;
continue;
}
if (!hasIterationCount &&
isValidValue(normalizeAnimationIterationCountItem, keyword)) {
result.iterationCount = keyword;
hasIterationCount = true;
continue;
}
if (!hasDirection &&
isValidValue(normalizeAnimationDirectionItem, keyword)) {
result.direction = keyword;
hasDirection = true;
continue;
}
if (!hasFillMode && isValidValue(normalizeAnimationFillModeItem, keyword)) {
result.fillMode = keyword;
hasFillMode = true;
continue;
}
if (!hasPlayState &&
isValidValue(normalizeAnimationPlayStateItem, keyword)) {
result.playState = keyword;
hasPlayState = true;
continue;
}
if (!hasName && isValidValue(normalizeAnimationNameItem, token)) {
result.name = token;
hasName = true;
continue;
}
return null;
}
// none 同时属于 animation-name 和 animation-fill-mode,按剩余槽位消歧。
for (let i = 0; i < noneCount; i++) {
if (!hasName) {
result.name = 'none';
hasName = true;
}
else if (!hasFillMode) {
result.fillMode = 'none';
hasFillMode = true;
}
else {
return null;
}
}
return result;
}
function parseAnimation(value) {
const items = splitAnimationList(value);
if (!items) {
return null;
}
const animations = [];
for (let i = 0; i < items.length; i++) {
const animation = parseSingleAnimation(items[i]);
if (!animation) {
return null;
}
animations.push(animation);
}
return {
name: animations.map((animation) => animation.name).join(','),
duration: animations.map((animation) => animation.duration).join(','),
delay: animations.map((animation) => animation.delay).join(','),
timingFunction: animations
.map((animation) => animation.timingFunction)
.join(','),
iterationCount: animations
.map((animation) => animation.iterationCount)
.join(','),
direction: animations.map((animation) => animation.direction).join(','),
fillMode: animations.map((animation) => animation.fillMode).join(','),
playState: animations.map((animation) => animation.playState).join(','),
};
}
function normalizeLengthValue(v, options, removePx, extraUnits = []) {
const match = v.match(LENGTH_REGEXP);
if (match) {
var unit = match[1];
const uvue = options.type === 'uvue';
if (uvue) {
if (!unit || (unit === 'px' && removePx)) {
return { value: parseFloat(v) };
}
else if (unit === 'px' || unit === 'rpx' || extraUnits.includes(unit)) {
return { value: v };
}
}
else {
// nvue
if (!unit || unit === 'px') {
return { value: parseFloat(v) };
}
if (SUPPORT_CSS_UNIT.includes(unit)) {
return { value: v };
}
else {
return {
value: parseFloat(v),
reason(k, v, result) {
return supportedUnitWithAutofixedReason(unit, v, result);
},
};
}
}
}
return {
value: null,
reason(k, v, result) {
return supportedEnumReason(k, v, ['number', 'pixel', ...extraUnits]);
},
};
}
const normalizePercent = (v) => {
v = (v || '').toString();
const match = v.match(LENGTH_REGEXP);
if (match) {
var unit = match[1];
if (unit === '%') {
return { value: v };
}
}
return {
value: null,
reason(k, v, result) {
return supportedEnumReason(k, v, ['percent']);
},
};
};
const normalizeGap = (value, options) => {
const text = String(value).trim();
if (/^(calc|var|env)\(/i.test(text) && text.endsWith(')')) {
return {
value: text.replace(/^(calc|var|env)(?=\()/i, (name) => name.toLowerCase()),
};
}
let result = normalizeLengthValue(text, options, !options.keepUnitPx);
if (result.value === null) {
result = normalizePercent(text);
}
const number = parseFloat(text);
if (result.value !== null && Number.isFinite(number) && number >= 0) {
return options.keepUnitPx ? { value: text } : result;
}
return {
value: null,
reason(property, value) {
return supportedEnumReason(property, value, [
'non-negative length',
'percentage',
]);
},
};
};
const animationName = 'animationName';
const animationDuration = 'animationDuration';
const animationDelay = 'animationDelay';
const animationTimingFunction = 'animationTimingFunction';
const animationIterationCount = 'animationIterationCount';
const animationDirection = 'animationDirection';
const animationFillMode = 'animationFillMode';
const animationPlayState = 'animationPlayState';
const animationLonghands = [
animationName,
animationDuration,
animationDelay,
animationTimingFunction,
animationIterationCount,
animationDirection,
animationFillMode,
animationPlayState,
];
function createTransformAnimation(options) {
return (decl, onWarning) => {
const { value, important, raws, source } = decl;
const singleVarResult = tryExpandSingleValueVarShorthand(decl, animationLonghands, value, !!options.dom2);
if (singleVarResult) {
return singleVarResult;
}
// animation 的各值域无法仅凭变量位置可靠判断,保留完整值交给运行时投影。
if (/\bvar\(/i.test(value)) {
return expandShorthand(decl, animationLonghands, value);
}
const animation = parseAnimation(value.trim());
if (!animation) {
return [decl];
}
return [
createDecl(animationName, animation.name, important, raws, source),
createDecl(animationDuration, animation.duration, important, raws, source),
createDecl(animationDelay, animation.delay, important, raws, source),
createDecl(animationTimingFunction, animation.timingFunction, important, raws, source),
createDecl(animationIterationCount, animation.iterationCount, important, raws, source),
createDecl(animationDirection, animation.direction, important, raws, source),
createDecl(animationFillMode, animation.fillMode, important, raws, source),
createDecl(animationPlayState, animation.playState, important, raws, source),
];
};
}
const rowGap = 'rowGap';
const columnGap = 'columnGap';
const transformGap = (decl, warn) => {
const { value, important, raws, source } = decl;
const values = (value.trim() ? splitValues(value) : ['']).map((value) => value
? normalizeGap(value, { type: 'uvue', dom2: true, keepUnitPx: true })
.value
: '');
if (values.length > 2 || values.some((value) => value === null)) {
if (warn) {
warn(`ERROR: property value \`${value}\` is not supported for \`gap\` (expected one or two non-negative lengths or percentages)`);
}
return [];
}
return [
createDecl(rowGap, String(values[0]), important, raws, source),
createDecl(columnGap, String(values[1] ?? values[0]), important, raws, source),
];
};
function getDeclTransforms(options, dom2) {
const transformBorder = options.type === 'uvue'
? createTransformBorder(options)
: createTransformBorderNvue();
const styleMap = {
transition: createTransformTransition(dom2),
border: transformBorder,
background: createTransformBackground(options),
['borderTop']: transformBorder,
['borderRight']: transformBorder,
['borderBottom']: transformBorder,
['borderLeft']: transformBorder,
['borderStyle']: options.type === 'uvue' ? transformBorderStyle : transformBorderStyleNvue,
['borderWidth']: options.type === 'uvue' ? transformBorderWidth : transformBorderWidthNvue,
['borderColor']: options.type === 'uvue' ? transformBorderColor : transformBorderColorNvue,
['borderRadius']: options.type === 'uvue'
? transformBorderRadius
: transformBorderRadiusNvue,
// uvue已经支持这些简写属性,不需要展开
// margin,padding继续展开,确保样式的优先级
margin: transformMargin,
padding: transformPadding,
['flexFlow']: createTransformFlexFlow(dom2),
};
if (options.type === 'uvue' && dom2) {
styleMap.animation = createTransformAnimation(options);
styleMap.gap = transformGap;
}
if (options.type === 'uvue') {
styleMap.flex = createTransformFlex(dom2);
}
let result = {};
{
result = styleMap;
}
return result;
}
const declTransforms = {};
const expanded = Symbol('expanded');
function expand(options) {
const type = options.type || 'nvue';
const dom2 = !!options.dom2;
const transformCacheKey = `${type}:${dom2}:${options.platform || ''}`;
const plugin = {
postcssPlugin: `${options.type || 'nvue'}:expand`,
Declaration(decl, helper) {
if (decl[expanded]) {
return;
}
const transforms = declTransforms[transformCacheKey] ||
(declTransforms[transformCacheKey] = getDeclTransforms(options, dom2));
const transform = transforms[decl.prop];
if (transform) {
const res = transform(decl, (reason, property = decl.prop) => {
if (!helper || !decl.warn) {
return;
}
let needLog = false;
if (options.logLevel === 'NOTE') {
needLog = true;
}
else if (options.logLevel === 'ERROR') {
if (reason.startsWith('ERROR:')) {
needLog = true;
}
}
else {
if (!reason.startsWith('NOTE:')) {
needLog = true;
}
}
if (needLog) {
decl.warn(helper.result, appendDom2Docs(reason, dom2 ? getDom2PropertyDocsUrl(property) : undefined));
}
});
const isSame = res.length === 1 && res[0] === decl;
if (!isSame) {
decl.replaceWith(res);
}
}
decl[expanded] = true;
},
};
return plugin;
}
export { expand };