Syllabus/themes/piratecare/node_modules/autoprefixer/lib/hacks/grid-utils.js

1150 lines
31 KiB
JavaScript
Raw Normal View History

2020-03-05 04:10:52 +00:00
"use strict";
var parser = require('postcss-value-parser');
var list = require('postcss').list;
var uniq = require('../utils').uniq;
var escapeRegexp = require('../utils').escapeRegexp;
var splitSelector = require('../utils').splitSelector;
function convert(value) {
if (value && value.length === 2 && value[0] === 'span' && parseInt(value[1], 10) > 0) {
return [false, parseInt(value[1], 10)];
}
if (value && value.length === 1 && parseInt(value[0], 10) > 0) {
return [parseInt(value[0], 10), false];
}
return [false, false];
}
function translate(values, startIndex, endIndex) {
var startValue = values[startIndex];
var endValue = values[endIndex];
if (!startValue) {
return [false, false];
}
var _convert = convert(startValue),
start = _convert[0],
spanStart = _convert[1];
var _convert2 = convert(endValue),
end = _convert2[0],
spanEnd = _convert2[1];
if (start && !endValue) {
return [start, false];
}
if (spanStart && end) {
return [end - spanStart, spanStart];
}
if (start && spanEnd) {
return [start, spanEnd];
}
if (start && end) {
return [start, end - start];
}
return [false, false];
}
function parse(decl) {
var node = parser(decl.value);
var values = [];
var current = 0;
values[current] = [];
for (var _iterator = node.nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
var _ref;
if (_isArray) {
if (_i >= _iterator.length) break;
_ref = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref = _i.value;
}
var i = _ref;
if (i.type === 'div') {
current += 1;
values[current] = [];
} else if (i.type === 'word') {
values[current].push(i.value);
}
}
return values;
}
function insertDecl(decl, prop, value) {
if (value && !decl.parent.some(function (i) {
return i.prop === "-ms-" + prop;
})) {
decl.cloneBefore({
prop: "-ms-" + prop,
value: value.toString()
});
}
} // Track transforms
function prefixTrackProp(_ref2) {
var prop = _ref2.prop,
prefix = _ref2.prefix;
return prefix + prop.replace('template-', '');
}
function transformRepeat(_ref3, _ref4) {
var nodes = _ref3.nodes;
var gap = _ref4.gap;
var _nodes$reduce = nodes.reduce(function (result, node) {
if (node.type === 'div' && node.value === ',') {
result.key = 'size';
} else {
result[result.key].push(parser.stringify(node));
}
return result;
}, {
key: 'count',
size: [],
count: []
}),
count = _nodes$reduce.count,
size = _nodes$reduce.size; // insert gap values
if (gap) {
var _ret = function () {
size = size.filter(function (i) {
return i.trim();
});
var val = [];
var _loop = function _loop(i) {
size.forEach(function (item, index) {
if (index > 0 || i > 1) {
val.push(gap);
}
val.push(item);
});
};
for (var i = 1; i <= count; i++) {
_loop(i);
}
return {
v: val.join(' ')
};
}();
if (typeof _ret === "object") return _ret.v;
}
return "(" + size.join('') + ")[" + count.join('') + "]";
}
function prefixTrackValue(_ref5) {
var value = _ref5.value,
gap = _ref5.gap;
var result = parser(value).nodes.reduce(function (nodes, node) {
if (node.type === 'function' && node.value === 'repeat') {
return nodes.concat({
type: 'word',
value: transformRepeat(node, {
gap: gap
})
});
}
if (gap && node.type === 'space') {
return nodes.concat({
type: 'space',
value: ' '
}, {
type: 'word',
value: gap
}, node);
}
return nodes.concat(node);
}, []);
return parser.stringify(result);
} // Parse grid-template-areas
var DOTS = /^\.+$/;
function track(start, end) {
return {
start: start,
end: end,
span: end - start
};
}
function getColumns(line) {
return line.trim().split(/\s+/g);
}
function parseGridAreas(_ref6) {
var rows = _ref6.rows,
gap = _ref6.gap;
return rows.reduce(function (areas, line, rowIndex) {
if (gap.row) rowIndex *= 2;
if (line.trim() === '') return areas;
getColumns(line).forEach(function (area, columnIndex) {
if (DOTS.test(area)) return;
if (gap.column) columnIndex *= 2;
if (typeof areas[area] === 'undefined') {
areas[area] = {
column: track(columnIndex + 1, columnIndex + 2),
row: track(rowIndex + 1, rowIndex + 2)
};
} else {
var _areas$area = areas[area],
column = _areas$area.column,
row = _areas$area.row;
column.start = Math.min(column.start, columnIndex + 1);
column.end = Math.max(column.end, columnIndex + 2);
column.span = column.end - column.start;
row.start = Math.min(row.start, rowIndex + 1);
row.end = Math.max(row.end, rowIndex + 2);
row.span = row.end - row.start;
}
});
return areas;
}, {});
} // Parse grid-template
function testTrack(node) {
return node.type === 'word' && /^\[.+]$/.test(node.value);
}
function verifyRowSize(result) {
if (result.areas.length > result.rows.length) {
result.rows.push('auto');
}
return result;
}
function parseTemplate(_ref7) {
var decl = _ref7.decl,
gap = _ref7.gap;
var gridTemplate = parser(decl.value).nodes.reduce(function (result, node) {
var type = node.type,
value = node.value;
if (testTrack(node) || type === 'space') return result; // area
if (type === 'string') {
result = verifyRowSize(result);
result.areas.push(value);
} // values and function
if (type === 'word' || type === 'function') {
result[result.key].push(parser.stringify(node));
} // divider(/)
if (type === 'div' && value === '/') {
result.key = 'columns';
result = verifyRowSize(result);
}
return result;
}, {
key: 'rows',
columns: [],
rows: [],
areas: []
});
return {
areas: parseGridAreas({
rows: gridTemplate.areas,
gap: gap
}),
columns: prefixTrackValue({
value: gridTemplate.columns.join(' '),
gap: gap.column
}),
rows: prefixTrackValue({
value: gridTemplate.rows.join(' '),
gap: gap.row
})
};
} // Insert parsed grid areas
/**
* Get an array of -ms- prefixed props and values
* @param {Object} [area] area object with column and row data
* @param {Boolean} [addRowSpan] should we add grid-column-row value?
* @param {Boolean} [addColumnSpan] should we add grid-column-span value?
* @return {Array<Object>}
*/
function getMSDecls(area, addRowSpan, addColumnSpan) {
if (addRowSpan === void 0) {
addRowSpan = false;
}
if (addColumnSpan === void 0) {
addColumnSpan = false;
}
return [].concat({
prop: '-ms-grid-row',
value: String(area.row.start)
}, area.row.span > 1 || addRowSpan ? {
prop: '-ms-grid-row-span',
value: String(area.row.span)
} : [], {
prop: '-ms-grid-column',
value: String(area.column.start)
}, area.column.span > 1 || addColumnSpan ? {
prop: '-ms-grid-column-span',
value: String(area.column.span)
} : []);
}
function getParentMedia(parent) {
if (parent.type === 'atrule' && parent.name === 'media') {
return parent;
}
if (!parent.parent) {
return false;
}
return getParentMedia(parent.parent);
}
/**
* change selectors for rules with duplicate grid-areas.
* @param {Array<Rule>} rules
* @param {Array<String>} templateSelectors
* @return {Array<Rule>} rules with changed selectors
*/
function changeDuplicateAreaSelectors(ruleSelectors, templateSelectors) {
ruleSelectors = ruleSelectors.map(function (selector) {
var selectorBySpace = list.space(selector);
var selectorByComma = list.comma(selector);
if (selectorBySpace.length > selectorByComma.length) {
selector = selectorBySpace.slice(-1).join('');
}
return selector;
});
return ruleSelectors.map(function (ruleSelector) {
var newSelector = templateSelectors.map(function (tplSelector, index) {
var space = index === 0 ? '' : ' ';
return "" + space + tplSelector + " > " + ruleSelector;
});
return newSelector;
});
}
/**
* check if selector of rules are equal
* @param {Rule} ruleA
* @param {Rule} ruleB
* @return {Boolean}
*/
function selectorsEqual(ruleA, ruleB) {
return ruleA.selectors.some(function (sel) {
return ruleB.selectors.some(function (s) {
return s === sel;
});
});
}
/**
* Parse data from all grid-template(-areas) declarations
* @param {Root} css css root
* @return {Object} parsed data
*/
function parseGridTemplatesData(css) {
var parsed = []; // we walk through every grid-template(-areas) declaration and store
// data with the same area names inside the item
css.walkDecls(/grid-template(-areas)?$/, function (d) {
var rule = d.parent;
var media = getParentMedia(rule);
var gap = getGridGap(d);
var inheritedGap = inheritGridGap(d, gap);
var _parseTemplate = parseTemplate({
decl: d,
gap: inheritedGap || gap
}),
areas = _parseTemplate.areas;
var areaNames = Object.keys(areas); // skip node if it doesn't have areas
if (areaNames.length === 0) {
return true;
} // check parsed array for item that include the same area names
// return index of that item
var index = parsed.reduce(function (acc, _ref8, idx) {
var allAreas = _ref8.allAreas;
var hasAreas = allAreas && areaNames.some(function (area) {
return allAreas.includes(area);
});
return hasAreas ? idx : acc;
}, null);
if (index !== null) {
// index is found, add the grid-template data to that item
var _parsed$index = parsed[index],
allAreas = _parsed$index.allAreas,
rules = _parsed$index.rules; // check if rule has no duplicate area names
var hasNoDuplicates = rules.some(function (r) {
return r.hasDuplicates === false && selectorsEqual(r, rule);
});
var duplicatesFound = false; // check need to gather all duplicate area names
var duplicateAreaNames = rules.reduce(function (acc, r) {
if (!r.params && selectorsEqual(r, rule)) {
duplicatesFound = true;
return r.duplicateAreaNames;
}
if (!duplicatesFound) {
areaNames.forEach(function (name) {
if (r.areas[name]) {
acc.push(name);
}
});
}
return uniq(acc);
}, []); // update grid-row/column-span values for areas with duplicate
// area names. @see #1084 and #1146
rules.forEach(function (r) {
areaNames.forEach(function (name) {
var area = r.areas[name];
if (area && area.row.span !== areas[name].row.span) {
areas[name].row.updateSpan = true;
}
if (area && area.column.span !== areas[name].column.span) {
areas[name].column.updateSpan = true;
}
});
});
parsed[index].allAreas = uniq([].concat(allAreas, areaNames));
parsed[index].rules.push({
hasDuplicates: !hasNoDuplicates,
params: media.params,
selectors: rule.selectors,
node: rule,
duplicateAreaNames: duplicateAreaNames,
areas: areas
});
} else {
// index is NOT found, push the new item to the parsed array
parsed.push({
allAreas: areaNames,
areasCount: 0,
rules: [{
hasDuplicates: false,
duplicateRules: [],
params: media.params,
selectors: rule.selectors,
node: rule,
duplicateAreaNames: [],
areas: areas
}]
});
}
return undefined;
});
return parsed;
}
/**
* insert prefixed grid-area declarations
* @param {Root} css css root
* @param {Function} isDisabled check if the rule is disabled
* @return {void}
*/
function insertAreas(css, isDisabled) {
// parse grid-template declarations
var gridTemplatesData = parseGridTemplatesData(css); // return undefined if no declarations found
if (gridTemplatesData.length === 0) {
return undefined;
} // we need to store the rules that we will insert later
var rulesToInsert = {};
css.walkDecls('grid-area', function (gridArea) {
var gridAreaRule = gridArea.parent;
var hasPrefixedRow = gridAreaRule.first.prop === '-ms-grid-row';
var gridAreaMedia = getParentMedia(gridAreaRule);
if (isDisabled(gridArea)) {
return undefined;
}
var gridAreaRuleIndex = gridAreaMedia ? css.index(gridAreaMedia) : css.index(gridAreaRule);
var value = gridArea.value; // found the data that matches grid-area identifier
var data = gridTemplatesData.filter(function (d) {
return d.allAreas.includes(value);
})[0];
if (!data) {
return true;
}
var lastArea = data.allAreas[data.allAreas.length - 1];
var selectorBySpace = list.space(gridAreaRule.selector);
var selectorByComma = list.comma(gridAreaRule.selector);
var selectorIsComplex = selectorBySpace.length > 1 && selectorBySpace.length > selectorByComma.length; // prevent doubling of prefixes
if (hasPrefixedRow) {
return false;
} // create the empty object with the key as the last area name
// e.g if we have templates with "a b c" values, "c" will be the last area
if (!rulesToInsert[lastArea]) {
rulesToInsert[lastArea] = {};
}
var lastRuleIsSet = false; // walk through every grid-template rule data
for (var _iterator2 = data.rules, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
var _ref9;
if (_isArray2) {
if (_i2 >= _iterator2.length) break;
_ref9 = _iterator2[_i2++];
} else {
_i2 = _iterator2.next();
if (_i2.done) break;
_ref9 = _i2.value;
}
var rule = _ref9;
var area = rule.areas[value];
var hasDuplicateName = rule.duplicateAreaNames.includes(value); // if we can't find the area name, update lastRule and continue
if (!area) {
var lastRuleIndex = css.index(rulesToInsert[lastArea].lastRule);
if (gridAreaRuleIndex > lastRuleIndex) {
rulesToInsert[lastArea].lastRule = gridAreaMedia || gridAreaRule;
}
continue;
} // for grid-templates inside media rule we need to create empty
// array to push prefixed grid-area rules later
if (rule.params && !rulesToInsert[lastArea][rule.params]) {
rulesToInsert[lastArea][rule.params] = [];
}
if ((!rule.hasDuplicates || !hasDuplicateName) && !rule.params) {
// grid-template has no duplicates and not inside media rule
getMSDecls(area, false, false).reverse().forEach(function (i) {
return gridAreaRule.prepend(Object.assign(i, {
raws: {
between: gridArea.raws.between
}
}));
});
rulesToInsert[lastArea].lastRule = gridAreaRule;
lastRuleIsSet = true;
} else if (rule.hasDuplicates && !rule.params && !selectorIsComplex) {
(function () {
// grid-template has duplicates and not inside media rule
var cloned = gridAreaRule.clone();
cloned.removeAll();
getMSDecls(area, area.row.updateSpan, area.column.updateSpan).reverse().forEach(function (i) {
return cloned.prepend(Object.assign(i, {
raws: {
between: gridArea.raws.between
}
}));
});
cloned.selectors = changeDuplicateAreaSelectors(cloned.selectors, rule.selectors);
if (rulesToInsert[lastArea].lastRule) {
rulesToInsert[lastArea].lastRule.after(cloned);
}
rulesToInsert[lastArea].lastRule = cloned;
lastRuleIsSet = true;
})();
} else if (rule.hasDuplicates && !rule.params && selectorIsComplex && gridAreaRule.selector.includes(rule.selectors[0])) {
// grid-template has duplicates and not inside media rule
// and the selector is complex
gridAreaRule.walkDecls(/-ms-grid-(row|column)/, function (d) {
return d.remove();
});
getMSDecls(area, area.row.updateSpan, area.column.updateSpan).reverse().forEach(function (i) {
return gridAreaRule.prepend(Object.assign(i, {
raws: {
between: gridArea.raws.between
}
}));
});
} else if (rule.params) {
(function () {
// grid-template is inside media rule
// if we're inside media rule, we need to store prefixed rules
// inside rulesToInsert object to be able to preserve the order of media
// rules and merge them easily
var cloned = gridAreaRule.clone();
cloned.removeAll();
getMSDecls(area, area.row.updateSpan, area.column.updateSpan).reverse().forEach(function (i) {
return cloned.prepend(Object.assign(i, {
raws: {
between: gridArea.raws.between
}
}));
});
if (rule.hasDuplicates && hasDuplicateName) {
cloned.selectors = changeDuplicateAreaSelectors(cloned.selectors, rule.selectors);
}
cloned.raws = rule.node.raws;
if (css.index(rule.node.parent) > gridAreaRuleIndex) {
// append the prefixed rules right inside media rule
// with grid-template
rule.node.parent.append(cloned);
} else {
// store the rule to insert later
rulesToInsert[lastArea][rule.params].push(cloned);
} // set new rule as last rule ONLY if we didn't set lastRule for
// this grid-area before
if (!lastRuleIsSet) {
rulesToInsert[lastArea].lastRule = gridAreaMedia || gridAreaRule;
}
})();
}
}
return undefined;
}); // append stored rules inside the media rules
Object.keys(rulesToInsert).forEach(function (area) {
var data = rulesToInsert[area];
var lastRule = data.lastRule;
Object.keys(data).reverse().filter(function (p) {
return p !== 'lastRule';
}).forEach(function (params) {
if (data[params].length > 0 && lastRule) {
lastRule.after({
name: 'media',
params: params
});
lastRule.next().append(data[params]);
}
});
});
return undefined;
}
/**
* Warn user if grid area identifiers are not found
* @param {Object} areas
* @param {Declaration} decl
* @param {Result} result
* @return {void}
*/
function warnMissedAreas(areas, decl, result) {
var missed = Object.keys(areas);
decl.root().walkDecls('grid-area', function (gridArea) {
missed = missed.filter(function (e) {
return e !== gridArea.value;
});
});
if (missed.length > 0) {
decl.warn(result, 'Can not find grid areas: ' + missed.join(', '));
}
return undefined;
}
/**
* compare selectors with grid-area rule and grid-template rule
* show warning if grid-template selector is not found
* (this function used for grid-area rule)
* @param {Declaration} decl
* @param {Result} result
* @return {void}
*/
function warnTemplateSelectorNotFound(decl, result) {
var rule = decl.parent;
var root = decl.root();
var duplicatesFound = false; // slice selector array. Remove the last part (for comparison)
var slicedSelectorArr = list.space(rule.selector).filter(function (str) {
return str !== '>';
}).slice(0, -1); // we need to compare only if selector is complex.
// e.g '.grid-cell' is simple, but '.parent > .grid-cell' is complex
if (slicedSelectorArr.length > 0) {
var gridTemplateFound = false;
var foundAreaSelector = null;
root.walkDecls(/grid-template(-areas)?$/, function (d) {
var parent = d.parent;
var templateSelectors = parent.selectors;
var _parseTemplate2 = parseTemplate({
decl: d,
gap: getGridGap(d)
}),
areas = _parseTemplate2.areas;
var hasArea = areas[decl.value]; // find the the matching selectors
for (var _iterator3 = templateSelectors, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
var _ref10;
if (_isArray3) {
if (_i3 >= _iterator3.length) break;
_ref10 = _iterator3[_i3++];
} else {
_i3 = _iterator3.next();
if (_i3.done) break;
_ref10 = _i3.value;
}
var tplSelector = _ref10;
if (gridTemplateFound) {
break;
}
var tplSelectorArr = list.space(tplSelector).filter(function (str) {
return str !== '>';
});
gridTemplateFound = tplSelectorArr.every(function (item, idx) {
return item === slicedSelectorArr[idx];
});
}
if (gridTemplateFound || !hasArea) {
return true;
}
if (!foundAreaSelector) {
foundAreaSelector = parent.selector;
} // if we found the duplicate area with different selector
if (foundAreaSelector && foundAreaSelector !== parent.selector) {
duplicatesFound = true;
}
return undefined;
}); // warn user if we didn't find template
if (!gridTemplateFound && duplicatesFound) {
decl.warn(result, 'Autoprefixer cannot find a grid-template ' + ("containing the duplicate grid-area \"" + decl.value + "\" ") + ("with full selector matching: " + slicedSelectorArr.join(' ')));
}
}
}
/**
* warn user if both grid-area and grid-(row|column)
* declarations are present in the same rule
* @param {Declaration} decl
* @param {Result} result
* @return {void}
*/
function warnIfGridRowColumnExists(decl, result) {
var rule = decl.parent;
var decls = [];
rule.walkDecls(/^grid-(row|column)/, function (d) {
if (!d.prop.endsWith('-end') && !d.value.startsWith('span')) {
decls.push(d);
}
});
if (decls.length > 0) {
decls.forEach(function (d) {
d.warn(result, 'You already have a grid-area declaration present in the rule. ' + ("You should use either grid-area or " + d.prop + ", not both"));
});
}
return undefined;
} // Gap utils
function getGridGap(decl) {
var gap = {}; // try to find gap
var testGap = /^(grid-)?((row|column)-)?gap$/;
decl.parent.walkDecls(testGap, function (_ref11) {
var prop = _ref11.prop,
value = _ref11.value;
if (/^(grid-)?gap$/.test(prop)) {
var _parser$nodes = parser(value).nodes,
row = _parser$nodes[0],
column = _parser$nodes[2];
gap.row = row && parser.stringify(row);
gap.column = column ? parser.stringify(column) : gap.row;
}
if (/^(grid-)?row-gap$/.test(prop)) gap.row = value;
if (/^(grid-)?column-gap$/.test(prop)) gap.column = value;
});
return gap;
}
/**
* parse media parameters (for example 'min-width: 500px')
* @param {String} params parameter to parse
* @return {}
*/
function parseMediaParams(params) {
if (!params) {
return false;
}
var parsed = parser(params);
var prop;
var value;
parsed.walk(function (node) {
if (node.type === 'word' && /min|max/g.test(node.value)) {
prop = node.value;
} else if (node.value.includes('px')) {
value = parseInt(node.value.replace(/\D/g, ''));
}
});
return [prop, value];
}
/**
* Compare the selectors and decide if we
* need to inherit gap from compared selector or not.
* @type {String} selA
* @type {String} selB
* @return {Boolean}
*/
function shouldInheritGap(selA, selB) {
var result; // get arrays of selector split in 3-deep array
var splitSelectorArrA = splitSelector(selA);
var splitSelectorArrB = splitSelector(selB);
if (splitSelectorArrA[0].length < splitSelectorArrB[0].length) {
// abort if selectorA has lower descendant specificity then selectorB
// (e.g '.grid' and '.hello .world .grid')
return false;
} else if (splitSelectorArrA[0].length > splitSelectorArrB[0].length) {
// if selectorA has higher descendant specificity then selectorB
// (e.g '.foo .bar .grid' and '.grid')
var idx = splitSelectorArrA[0].reduce(function (res, _ref12, index) {
var item = _ref12[0];
var firstSelectorPart = splitSelectorArrB[0][0][0];
if (item === firstSelectorPart) {
return index;
}
return false;
}, false);
if (idx) {
result = splitSelectorArrB[0].every(function (arr, index) {
return arr.every(function (part, innerIndex) {
return (// because selectorA has more space elements, we need to slice
// selectorA array by 'idx' number to compare them
splitSelectorArrA[0].slice(idx)[index][innerIndex] === part
);
});
});
}
} else {
// if selectorA has the same descendant specificity as selectorB
// this condition covers cases such as: '.grid.foo.bar' and '.grid'
result = splitSelectorArrB.some(function (byCommaArr) {
return byCommaArr.every(function (bySpaceArr, index) {
return bySpaceArr.every(function (part, innerIndex) {
return splitSelectorArrA[0][index][innerIndex] === part;
});
});
});
}
return result;
}
/**
* inherit grid gap values from the closest rule above
* with the same selector
* @param {Declaration} decl
* @param {Object} gap gap values
* @return {Object | Boolean} return gap values or false (if not found)
*/
function inheritGridGap(decl, gap) {
var rule = decl.parent;
var mediaRule = getParentMedia(rule);
var root = rule.root(); // get an array of selector split in 3-deep array
var splitSelectorArr = splitSelector(rule.selector); // abort if the rule already has gaps
if (Object.keys(gap).length > 0) {
return false;
} // e.g ['min-width']
var _parseMediaParams = parseMediaParams(mediaRule.params),
prop = _parseMediaParams[0];
var lastBySpace = splitSelectorArr[0]; // get escaped value from the selector
// if we have '.grid-2.foo.bar' selector, will be '\.grid\-2'
var escaped = escapeRegexp(lastBySpace[lastBySpace.length - 1][0]);
var regexp = new RegExp("(" + escaped + "$)|(" + escaped + "[,.])"); // find the closest rule with the same selector
var closestRuleGap;
root.walkRules(regexp, function (r) {
var gridGap; // abort if are checking the same rule
if (rule.toString() === r.toString()) {
return false;
} // find grid-gap values
r.walkDecls('grid-gap', function (d) {
return gridGap = getGridGap(d);
}); // skip rule without gaps
if (!gridGap || Object.keys(gridGap).length === 0) {
return true;
} // skip rules that should not be inherited from
if (!shouldInheritGap(rule.selector, r.selector)) {
return true;
}
var media = getParentMedia(r);
if (media) {
// if we are inside media, we need to check that media props match
// e.g ('min-width' === 'min-width')
var propToCompare = parseMediaParams(media.params)[0];
if (propToCompare === prop) {
closestRuleGap = gridGap;
return true;
}
} else {
closestRuleGap = gridGap;
return true;
}
return undefined;
}); // if we find the closest gap object
if (closestRuleGap && Object.keys(closestRuleGap).length > 0) {
return closestRuleGap;
}
return false;
}
function warnGridGap(_ref13) {
var gap = _ref13.gap,
hasColumns = _ref13.hasColumns,
decl = _ref13.decl,
result = _ref13.result;
var hasBothGaps = gap.row && gap.column;
if (!hasColumns && (hasBothGaps || gap.column && !gap.row)) {
delete gap.column;
decl.warn(result, 'Can not implement grid-gap without grid-template-columns');
}
}
/**
* normalize the grid-template-rows/columns values
* @param {String} str grid-template-rows/columns value
* @return {Array} normalized array with values
* @example
* let normalized = normalizeRowColumn('1fr repeat(2, 20px 50px) 1fr')
* normalized // <= ['1fr', '20px', '50px', '20px', '50px', '1fr']
*/
function normalizeRowColumn(str) {
var normalized = parser(str).nodes.reduce(function (result, node) {
if (node.type === 'function' && node.value === 'repeat') {
var key = 'count';
var _node$nodes$reduce = node.nodes.reduce(function (acc, n) {
if (n.type === 'word' && key === 'count') {
acc[0] = Math.abs(parseInt(n.value));
return acc;
}
if (n.type === 'div' && n.value === ',') {
key = 'value';
return acc;
}
if (key === 'value') {
acc[1] += parser.stringify(n);
}
return acc;
}, [0, '']),
count = _node$nodes$reduce[0],
value = _node$nodes$reduce[1];
if (count) {
for (var i = 0; i < count; i++) {
result.push(value);
}
}
return result;
}
if (node.type === 'space') {
return result;
}
return result.concat(parser.stringify(node));
}, []);
return normalized;
}
/**
* Autoplace grid items
* @param {Declaration} decl
* @param {Result} result
* @param {Object} gap gap values
* @param {String} autoflowValue grid-auto-flow value
* @return {void}
* @see https://github.com/postcss/autoprefixer/issues/1148
*/
function autoplaceGridItems(decl, result, gap, autoflowValue) {
if (autoflowValue === void 0) {
autoflowValue = 'row';
}
var parent = decl.parent;
var rowDecl = parent.nodes.find(function (i) {
return i.prop === 'grid-template-rows';
});
var rows = normalizeRowColumn(rowDecl.value);
var columns = normalizeRowColumn(decl.value); // Build array of area names with dummy values. If we have 3 columns and
// 2 rows, filledRows will be equal to ['1 2 3', '4 5 6']
var filledRows = rows.map(function (_, rowIndex) {
return Array.from({
length: columns.length
}, function (v, k) {
return k + rowIndex * columns.length + 1;
}).join(' ');
});
var areas = parseGridAreas({
rows: filledRows,
gap: gap
});
var keys = Object.keys(areas);
var items = keys.map(function (i) {
return areas[i];
}); // Change the order of cells if grid-auto-flow value is 'column'
if (autoflowValue.includes('column')) {
items = items.sort(function (a, b) {
return a.column.start - b.column.start;
});
} // Insert new rules
items.reverse().forEach(function (item, index) {
var column = item.column,
row = item.row;
var nodeSelector = parent.selectors.map(function (sel) {
return sel + (" > *:nth-child(" + (keys.length - index) + ")");
}).join(', '); // create new rule
var node = parent.clone().removeAll(); // change rule selector
node.selector = nodeSelector; // insert prefixed row/column values
node.append({
prop: '-ms-grid-row',
value: row.start
});
node.append({
prop: '-ms-grid-column',
value: column.start
}); // insert rule
parent.after(node);
});
return undefined;
}
module.exports = {
parse: parse,
translate: translate,
parseTemplate: parseTemplate,
parseGridAreas: parseGridAreas,
warnMissedAreas: warnMissedAreas,
insertAreas: insertAreas,
insertDecl: insertDecl,
prefixTrackProp: prefixTrackProp,
prefixTrackValue: prefixTrackValue,
getGridGap: getGridGap,
warnGridGap: warnGridGap,
warnTemplateSelectorNotFound: warnTemplateSelectorNotFound,
warnIfGridRowColumnExists: warnIfGridRowColumnExists,
inheritGridGap: inheritGridGap,
autoplaceGridItems: autoplaceGridItems
};