summaryrefslogtreecommitdiff
path: root/node_modules/autoprefixer/lib/hacks/grid-utils.js
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/autoprefixer/lib/hacks/grid-utils.js')
-rw-r--r--node_modules/autoprefixer/lib/hacks/grid-utils.js1113
1 files changed, 1113 insertions, 0 deletions
diff --git a/node_modules/autoprefixer/lib/hacks/grid-utils.js b/node_modules/autoprefixer/lib/hacks/grid-utils.js
new file mode 100644
index 0000000..e894231
--- /dev/null
+++ b/node_modules/autoprefixer/lib/hacks/grid-utils.js
@@ -0,0 +1,1113 @@
+let parser = require('postcss-value-parser')
+let list = require('postcss').list
+
+let uniq = require('../utils').uniq
+let escapeRegexp = require('../utils').escapeRegexp
+let 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]
+}
+
+exports.translate = translate
+
+function translate(values, startIndex, endIndex) {
+ let startValue = values[startIndex]
+ let endValue = values[endIndex]
+
+ if (!startValue) {
+ return [false, false]
+ }
+
+ let [start, spanStart] = convert(startValue)
+ let [end, spanEnd] = convert(endValue)
+
+ 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]
+}
+
+exports.parse = parse
+
+function parse(decl) {
+ let node = parser(decl.value)
+
+ let values = []
+ let current = 0
+ values[current] = []
+
+ for (let i of node.nodes) {
+ if (i.type === 'div') {
+ current += 1
+ values[current] = []
+ } else if (i.type === 'word') {
+ values[current].push(i.value)
+ }
+ }
+
+ return values
+}
+
+exports.insertDecl = insertDecl
+
+function insertDecl(decl, prop, value) {
+ if (value && !decl.parent.some(i => i.prop === `-ms-${prop}`)) {
+ decl.cloneBefore({
+ prop: `-ms-${prop}`,
+ value: value.toString()
+ })
+ }
+}
+
+// Track transforms
+
+exports.prefixTrackProp = prefixTrackProp
+
+function prefixTrackProp({ prefix, prop }) {
+ return prefix + prop.replace('template-', '')
+}
+
+function transformRepeat({ nodes }, { gap }) {
+ let { count, size } = nodes.reduce(
+ (result, node) => {
+ if (node.type === 'div' && node.value === ',') {
+ result.key = 'size'
+ } else {
+ result[result.key].push(parser.stringify(node))
+ }
+ return result
+ },
+ {
+ count: [],
+ key: 'count',
+ size: []
+ }
+ )
+
+ // insert gap values
+ if (gap) {
+ size = size.filter(i => i.trim())
+ let val = []
+ for (let i = 1; i <= count; i++) {
+ size.forEach((item, index) => {
+ if (index > 0 || i > 1) {
+ val.push(gap)
+ }
+ val.push(item)
+ })
+ }
+
+ return val.join(' ')
+ }
+
+ return `(${size.join('')})[${count.join('')}]`
+}
+
+exports.prefixTrackValue = prefixTrackValue
+
+function prefixTrackValue({ gap, value }) {
+ let result = parser(value).nodes.reduce((nodes, node) => {
+ if (node.type === 'function' && node.value === 'repeat') {
+ return nodes.concat({
+ type: 'word',
+ value: transformRepeat(node, { 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
+
+let DOTS = /^\.+$/
+
+function track(start, end) {
+ return { end, span: end - start, start }
+}
+
+function getColumns(line) {
+ return line.trim().split(/\s+/g)
+}
+
+exports.parseGridAreas = parseGridAreas
+
+function parseGridAreas({ gap, rows }) {
+ return rows.reduce((areas, line, rowIndex) => {
+ if (gap.row) rowIndex *= 2
+
+ if (line.trim() === '') return areas
+
+ getColumns(line).forEach((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 {
+ let { column, row } = areas[area]
+
+ 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
+}
+
+exports.parseTemplate = parseTemplate
+
+function parseTemplate({ decl, gap }) {
+ let gridTemplate = parser(decl.value).nodes.reduce(
+ (result, node) => {
+ let { type, value } = node
+
+ 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
+ },
+ {
+ areas: [],
+ columns: [],
+ key: 'rows',
+ rows: []
+ }
+ )
+
+ return {
+ areas: parseGridAreas({
+ gap,
+ rows: gridTemplate.areas
+ }),
+ columns: prefixTrackValue({
+ gap: gap.column,
+ value: gridTemplate.columns.join(' ')
+ }),
+ rows: prefixTrackValue({
+ gap: gap.row,
+ value: gridTemplate.rows.join(' ')
+ })
+ }
+}
+
+// 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 = false, addColumnSpan = false) {
+ let result = [
+ {
+ prop: '-ms-grid-row',
+ value: String(area.row.start)
+ }
+ ]
+ if (area.row.span > 1 || addRowSpan) {
+ result.push({
+ prop: '-ms-grid-row-span',
+ value: String(area.row.span)
+ })
+ }
+ result.push({
+ prop: '-ms-grid-column',
+ value: String(area.column.start)
+ })
+ if (area.column.span > 1 || addColumnSpan) {
+ result.push({
+ prop: '-ms-grid-column-span',
+ value: String(area.column.span)
+ })
+ }
+ return result
+}
+
+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(selector => {
+ let selectorBySpace = list.space(selector)
+ let selectorByComma = list.comma(selector)
+
+ if (selectorBySpace.length > selectorByComma.length) {
+ selector = selectorBySpace.slice(-1).join('')
+ }
+ return selector
+ })
+
+ return ruleSelectors.map(ruleSelector => {
+ let newSelector = templateSelectors.map((tplSelector, index) => {
+ let 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(sel => {
+ return ruleB.selectors.includes(sel)
+ })
+}
+
+/**
+ * Parse data from all grid-template(-areas) declarations
+ * @param {Root} css css root
+ * @return {Object} parsed data
+ */
+function parseGridTemplatesData(css) {
+ let 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)?$/, d => {
+ let rule = d.parent
+ let media = getParentMedia(rule)
+ let gap = getGridGap(d)
+ let inheritedGap = inheritGridGap(d, gap)
+ let { areas } = parseTemplate({ decl: d, gap: inheritedGap || gap })
+ let 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
+ let index = parsed.reduce((acc, { allAreas }, idx) => {
+ let hasAreas = allAreas && areaNames.some(area => allAreas.includes(area))
+ return hasAreas ? idx : acc
+ }, null)
+
+ if (index !== null) {
+ // index is found, add the grid-template data to that item
+ let { allAreas, rules } = parsed[index]
+
+ // check if rule has no duplicate area names
+ let hasNoDuplicates = rules.some(r => {
+ return r.hasDuplicates === false && selectorsEqual(r, rule)
+ })
+
+ let duplicatesFound = false
+
+ // check need to gather all duplicate area names
+ let duplicateAreaNames = rules.reduce((acc, r) => {
+ if (!r.params && selectorsEqual(r, rule)) {
+ duplicatesFound = true
+ return r.duplicateAreaNames
+ }
+ if (!duplicatesFound) {
+ areaNames.forEach(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(r => {
+ areaNames.forEach(name => {
+ let 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([...allAreas, ...areaNames])
+ parsed[index].rules.push({
+ areas,
+ duplicateAreaNames,
+ hasDuplicates: !hasNoDuplicates,
+ node: rule,
+ params: media.params,
+ selectors: rule.selectors
+ })
+ } else {
+ // index is NOT found, push the new item to the parsed array
+ parsed.push({
+ allAreas: areaNames,
+ areasCount: 0,
+ rules: [
+ {
+ areas,
+ duplicateAreaNames: [],
+ duplicateRules: [],
+ hasDuplicates: false,
+ node: rule,
+ params: media.params,
+ selectors: rule.selectors
+ }
+ ]
+ })
+ }
+
+ 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}
+ */
+exports.insertAreas = insertAreas
+
+function insertAreas(css, isDisabled) {
+ // parse grid-template declarations
+ let 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
+ let rulesToInsert = {}
+
+ css.walkDecls('grid-area', gridArea => {
+ let gridAreaRule = gridArea.parent
+ let hasPrefixedRow = gridAreaRule.first.prop === '-ms-grid-row'
+ let gridAreaMedia = getParentMedia(gridAreaRule)
+
+ if (isDisabled(gridArea)) {
+ return undefined
+ }
+
+ let gridAreaRuleIndex = css.index(gridAreaMedia || gridAreaRule)
+
+ let value = gridArea.value
+ // found the data that matches grid-area identifier
+ let data = gridTemplatesData.filter(d => d.allAreas.includes(value))[0]
+
+ if (!data) {
+ return true
+ }
+
+ let lastArea = data.allAreas[data.allAreas.length - 1]
+ let selectorBySpace = list.space(gridAreaRule.selector)
+ let selectorByComma = list.comma(gridAreaRule.selector)
+ let 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] = {}
+ }
+
+ let lastRuleIsSet = false
+
+ // walk through every grid-template rule data
+ for (let rule of data.rules) {
+ let area = rule.areas[value]
+ let hasDuplicateName = rule.duplicateAreaNames.includes(value)
+
+ // if we can't find the area name, update lastRule and continue
+ if (!area) {
+ let lastRule = rulesToInsert[lastArea].lastRule
+ let lastRuleIndex
+ if (lastRule) {
+ lastRuleIndex = css.index(lastRule)
+ } else {
+ /* c8 ignore next 2 */
+ lastRuleIndex = -1
+ }
+
+ 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(i =>
+ gridAreaRule.prepend(
+ Object.assign(i, {
+ raws: {
+ between: gridArea.raws.between
+ }
+ })
+ )
+ )
+
+ rulesToInsert[lastArea].lastRule = gridAreaRule
+ lastRuleIsSet = true
+ } else if (rule.hasDuplicates && !rule.params && !selectorIsComplex) {
+ // grid-template has duplicates and not inside media rule
+ let cloned = gridAreaRule.clone()
+ cloned.removeAll()
+
+ getMSDecls(area, area.row.updateSpan, area.column.updateSpan)
+ .reverse()
+ .forEach(i =>
+ 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)/, d => d.remove())
+ getMSDecls(area, area.row.updateSpan, area.column.updateSpan)
+ .reverse()
+ .forEach(i =>
+ gridAreaRule.prepend(
+ Object.assign(i, {
+ raws: {
+ between: gridArea.raws.between
+ }
+ })
+ )
+ )
+ } else if (rule.params) {
+ // 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
+ let cloned = gridAreaRule.clone()
+ cloned.removeAll()
+
+ getMSDecls(area, area.row.updateSpan, area.column.updateSpan)
+ .reverse()
+ .forEach(i =>
+ 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(area => {
+ let data = rulesToInsert[area]
+ let lastRule = data.lastRule
+ Object.keys(data)
+ .reverse()
+ .filter(p => p !== 'lastRule')
+ .forEach(params => {
+ if (data[params].length > 0 && lastRule) {
+ lastRule.after({ name: 'media', 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}
+ */
+exports.warnMissedAreas = warnMissedAreas
+
+function warnMissedAreas(areas, decl, result) {
+ let missed = Object.keys(areas)
+
+ decl.root().walkDecls('grid-area', gridArea => {
+ missed = missed.filter(e => 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}
+ */
+exports.warnTemplateSelectorNotFound = warnTemplateSelectorNotFound
+
+function warnTemplateSelectorNotFound(decl, result) {
+ let rule = decl.parent
+ let root = decl.root()
+ let duplicatesFound = false
+
+ // slice selector array. Remove the last part (for comparison)
+ let slicedSelectorArr = list
+ .space(rule.selector)
+ .filter(str => 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) {
+ let gridTemplateFound = false
+ let foundAreaSelector = null
+
+ root.walkDecls(/grid-template(-areas)?$/, d => {
+ let parent = d.parent
+ let templateSelectors = parent.selectors
+
+ let { areas } = parseTemplate({ decl: d, gap: getGridGap(d) })
+ let hasArea = areas[decl.value]
+
+ // find the the matching selectors
+ for (let tplSelector of templateSelectors) {
+ if (gridTemplateFound) {
+ break
+ }
+ let tplSelectorArr = list.space(tplSelector).filter(str => str !== '>')
+
+ gridTemplateFound = tplSelectorArr.every(
+ (item, idx) => 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}
+ */
+exports.warnIfGridRowColumnExists = warnIfGridRowColumnExists
+
+function warnIfGridRowColumnExists(decl, result) {
+ let rule = decl.parent
+ let decls = []
+ rule.walkDecls(/^grid-(row|column)/, d => {
+ if (
+ !d.prop.endsWith('-end') &&
+ !d.value.startsWith('span') &&
+ !d.prop.endsWith('-gap')
+ ) {
+ decls.push(d)
+ }
+ })
+ if (decls.length > 0) {
+ decls.forEach(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
+
+exports.getGridGap = getGridGap
+
+function getGridGap(decl) {
+ let gap = {}
+
+ // try to find gap
+ let testGap = /^(grid-)?((row|column)-)?gap$/
+ decl.parent.walkDecls(testGap, ({ prop, value }) => {
+ if (/^(grid-)?gap$/.test(prop)) {
+ let [row, , column] = parser(value).nodes
+
+ 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 []
+ }
+ let parsed = parser(params)
+ let prop
+ let value
+
+ parsed.walk(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) {
+ let result
+
+ // get arrays of selector split in 3-deep array
+ let splitSelectorArrA = splitSelector(selA)
+ let 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')
+
+ let idx = splitSelectorArrA[0].reduce((res, [item], index) => {
+ let firstSelectorPart = splitSelectorArrB[0][0][0]
+ if (item === firstSelectorPart) {
+ return index
+ }
+ return false
+ }, false)
+
+ if (idx) {
+ result = splitSelectorArrB[0].every((arr, index) => {
+ return arr.every(
+ (part, innerIndex) =>
+ // 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(byCommaArr => {
+ return byCommaArr.every((bySpaceArr, index) => {
+ return bySpaceArr.every(
+ (part, innerIndex) => 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)
+ */
+exports.inheritGridGap = inheritGridGap
+
+function inheritGridGap(decl, gap) {
+ let rule = decl.parent
+ let mediaRule = getParentMedia(rule)
+ let root = rule.root()
+
+ // get an array of selector split in 3-deep array
+ let splitSelectorArr = splitSelector(rule.selector)
+
+ // abort if the rule already has gaps
+ if (Object.keys(gap).length > 0) {
+ return false
+ }
+
+ // e.g ['min-width']
+ let [prop] = parseMediaParams(mediaRule.params)
+
+ let lastBySpace = splitSelectorArr[0]
+
+ // get escaped value from the selector
+ // if we have '.grid-2.foo.bar' selector, will be '\.grid\-2'
+ let escaped = escapeRegexp(lastBySpace[lastBySpace.length - 1][0])
+
+ let regexp = new RegExp(`(${escaped}$)|(${escaped}[,.])`)
+
+ // find the closest rule with the same selector
+ let closestRuleGap
+ root.walkRules(regexp, r => {
+ let gridGap
+
+ // abort if are checking the same rule
+ if (rule.toString() === r.toString()) {
+ return false
+ }
+
+ // find grid-gap values
+ r.walkDecls('grid-gap', d => (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
+ }
+
+ let media = getParentMedia(r)
+ if (media) {
+ // if we are inside media, we need to check that media props match
+ // e.g ('min-width' === 'min-width')
+ let 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
+}
+
+exports.warnGridGap = warnGridGap
+
+function warnGridGap({ decl, gap, hasColumns, result }) {
+ let 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) {
+ let normalized = parser(str).nodes.reduce((result, node) => {
+ if (node.type === 'function' && node.value === 'repeat') {
+ let key = 'count'
+
+ let [count, value] = node.nodes.reduce(
+ (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, '']
+ )
+
+ if (count) {
+ for (let i = 0; i < count; i++) {
+ result.push(value)
+ }
+ }
+
+ return result
+ }
+ if (node.type === 'space') {
+ return result
+ }
+ return result.concat(parser.stringify(node))
+ }, [])
+
+ return normalized
+}
+
+exports.autoplaceGridItems = autoplaceGridItems
+
+/**
+ * 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 = 'row') {
+ let { parent } = decl
+
+ let rowDecl = parent.nodes.find(i => i.prop === 'grid-template-rows')
+ let rows = normalizeRowColumn(rowDecl.value)
+ let 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']
+ let filledRows = rows.map((_, rowIndex) => {
+ return Array.from(
+ { length: columns.length },
+ (v, k) => k + rowIndex * columns.length + 1
+ ).join(' ')
+ })
+
+ let areas = parseGridAreas({ gap, rows: filledRows })
+ let keys = Object.keys(areas)
+ let items = keys.map(i => areas[i])
+
+ // Change the order of cells if grid-auto-flow value is 'column'
+ if (autoflowValue.includes('column')) {
+ items = items.sort((a, b) => a.column.start - b.column.start)
+ }
+
+ // Insert new rules
+ items.reverse().forEach((item, index) => {
+ let { column, row } = item
+ let nodeSelector = parent.selectors
+ .map(sel => sel + ` > *:nth-child(${keys.length - index})`)
+ .join(', ')
+
+ // create new rule
+ let 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
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-06 11:09:58 +0000