tailwindcss 3.4.0 → 4.0.0-alpha.1

package/src/util/pluginUtils.js

@@ -1,307 +0,0 @@
-import escapeCommas from './escapeCommas'
-import { withAlphaValue } from './withAlphaVariable'
-import {
-  normalize,
-  length,
-  number,
-  percentage,
-  url,
-  color as validateColor,
-  genericName,
-  familyName,
-  image,
-  absoluteSize,
-  relativeSize,
-  position,
-  lineWidth,
-  shadow,
-} from './dataTypes'
-import negateValue from './negateValue'
-import { backgroundSize } from './validateFormalSyntax'
-import { flagEnabled } from '../featureFlags.js'
-
-/**
- * @param {import('postcss-selector-parser').Container} selectors
- * @param {(className: string) => string} updateClass
- * @returns {string}
- */
-export function updateAllClasses(selectors, updateClass) {
-  selectors.walkClasses((sel) => {
-    sel.value = updateClass(sel.value)
-
-    if (sel.raws && sel.raws.value) {
-      sel.raws.value = escapeCommas(sel.raws.value)
-    }
-  })
-}
-
-function resolveArbitraryValue(modifier, validate) {
-  if (!isArbitraryValue(modifier)) {
-    return undefined
-  }
-
-  let value = modifier.slice(1, -1)
-
-  if (!validate(value)) {
-    return undefined
-  }
-
-  return normalize(value)
-}
-
-function asNegativeValue(modifier, lookup = {}, validate) {
-  let positiveValue = lookup[modifier]
-
-  if (positiveValue !== undefined) {
-    return negateValue(positiveValue)
-  }
-
-  if (isArbitraryValue(modifier)) {
-    let resolved = resolveArbitraryValue(modifier, validate)
-
-    if (resolved === undefined) {
-      return undefined
-    }
-
-    return negateValue(resolved)
-  }
-}
-
-export function asValue(modifier, options = {}, { validate = () => true } = {}) {
-  let value = options.values?.[modifier]
-
-  if (value !== undefined) {
-    return value
-  }
-
-  if (options.supportsNegativeValues && modifier.startsWith('-')) {
-    return asNegativeValue(modifier.slice(1), options.values, validate)
-  }
-
-  return resolveArbitraryValue(modifier, validate)
-}
-
-function isArbitraryValue(input) {
-  return input.startsWith('[') && input.endsWith(']')
-}
-
-function splitUtilityModifier(modifier) {
-  let slashIdx = modifier.lastIndexOf('/')
-
-  // If the `/` is inside an arbitrary, we want to find the previous one if any
-  // This logic probably isn't perfect but it should work for most cases
-  let arbitraryStartIdx = modifier.lastIndexOf('[', slashIdx)
-  let arbitraryEndIdx = modifier.indexOf(']', slashIdx)
-
-  let isNextToArbitrary = modifier[slashIdx - 1] === ']' || modifier[slashIdx + 1] === '['
-
-  // Backtrack to the previous `/` if the one we found was inside an arbitrary
-  if (!isNextToArbitrary) {
-    if (arbitraryStartIdx !== -1 && arbitraryEndIdx !== -1) {
-      if (arbitraryStartIdx < slashIdx && slashIdx < arbitraryEndIdx) {
-        slashIdx = modifier.lastIndexOf('/', arbitraryStartIdx)
-      }
-    }
-  }
-
-  if (slashIdx === -1 || slashIdx === modifier.length - 1) {
-    return [modifier, undefined]
-  }
-
-  let arbitrary = isArbitraryValue(modifier)
-
-  // The modifier could be of the form `[foo]/[bar]`
-  // We want to handle this case properly
-  // without affecting `[foo/bar]`
-  if (arbitrary && !modifier.includes(']/[')) {
-    return [modifier, undefined]
-  }
-
-  return [modifier.slice(0, slashIdx), modifier.slice(slashIdx + 1)]
-}
-
-export function parseColorFormat(value) {
-  if (typeof value === 'string' && value.includes('<alpha-value>')) {
-    let oldValue = value
-
-    return ({ opacityValue = 1 }) => oldValue.replace('<alpha-value>', opacityValue)
-  }
-
-  return value
-}
-
-function unwrapArbitraryModifier(modifier) {
-  return normalize(modifier.slice(1, -1))
-}
-
-export function asColor(modifier, options = {}, { tailwindConfig = {} } = {}) {
-  if (options.values?.[modifier] !== undefined) {
-    return parseColorFormat(options.values?.[modifier])
-  }
-
-  // TODO: Hoist this up to getMatchingTypes or something
-  // We do this here because we need the alpha value (if any)
-  let [color, alpha] = splitUtilityModifier(modifier)
-
-  if (alpha !== undefined) {
-    let normalizedColor =
-      options.values?.[color] ?? (isArbitraryValue(color) ? color.slice(1, -1) : undefined)
-
-    if (normalizedColor === undefined) {
-      return undefined
-    }
-
-    normalizedColor = parseColorFormat(normalizedColor)
-
-    if (isArbitraryValue(alpha)) {
-      return withAlphaValue(normalizedColor, unwrapArbitraryModifier(alpha))
-    }
-
-    if (tailwindConfig.theme?.opacity?.[alpha] === undefined) {
-      return undefined
-    }
-
-    return withAlphaValue(normalizedColor, tailwindConfig.theme.opacity[alpha])
-  }
-
-  return asValue(modifier, options, { validate: validateColor })
-}
-
-export function asLookupValue(modifier, options = {}) {
-  return options.values?.[modifier]
-}
-
-function guess(validate) {
-  return (modifier, options) => {
-    return asValue(modifier, options, { validate })
-  }
-}
-
-export let typeMap = {
-  any: asValue,
-  color: asColor,
-  url: guess(url),
-  image: guess(image),
-  length: guess(length),
-  percentage: guess(percentage),
-  position: guess(position),
-  lookup: asLookupValue,
-  'generic-name': guess(genericName),
-  'family-name': guess(familyName),
-  number: guess(number),
-  'line-width': guess(lineWidth),
-  'absolute-size': guess(absoluteSize),
-  'relative-size': guess(relativeSize),
-  shadow: guess(shadow),
-  size: guess(backgroundSize),
-}
-
-let supportedTypes = Object.keys(typeMap)
-
-function splitAtFirst(input, delim) {
-  let idx = input.indexOf(delim)
-  if (idx === -1) return [undefined, input]
-  return [input.slice(0, idx), input.slice(idx + 1)]
-}
-
-export function coerceValue(types, modifier, options, tailwindConfig) {
-  if (options.values && modifier in options.values) {
-    for (let { type } of types ?? []) {
-      let result = typeMap[type](modifier, options, {
-        tailwindConfig,
-      })
-
-      if (result === undefined) {
-        continue
-      }
-
-      return [result, type, null]
-    }
-  }
-
-  if (isArbitraryValue(modifier)) {
-    let arbitraryValue = modifier.slice(1, -1)
-    let [explicitType, value] = splitAtFirst(arbitraryValue, ':')
-
-    // It could be that this resolves to `url(https` which is not a valid
-    // identifier. We currently only support "simple" words with dashes or
-    // underscores. E.g.: family-name
-    if (!/^[\w-_]+$/g.test(explicitType)) {
-      value = arbitraryValue
-    }
-
-    //
-    else if (explicitType !== undefined && !supportedTypes.includes(explicitType)) {
-      return []
-    }
-
-    if (value.length > 0 && supportedTypes.includes(explicitType)) {
-      return [asValue(`[${value}]`, options), explicitType, null]
-    }
-  }
-
-  let matches = getMatchingTypes(types, modifier, options, tailwindConfig)
-
-  // Find first matching type
-  for (let match of matches) {
-    return match
-  }
-
-  return []
-}
-
-/**
- *
- * @param {{type: string}[]} types
- * @param {string} rawModifier
- * @param {any} options
- * @param {any} tailwindConfig
- * @returns {Iterator<[value: string, type: string, modifier: string | null]>}
- */
-export function* getMatchingTypes(types, rawModifier, options, tailwindConfig) {
-  let modifiersEnabled = flagEnabled(tailwindConfig, 'generalizedModifiers')
-
-  let [modifier, utilityModifier] = splitUtilityModifier(rawModifier)
-
-  let canUseUtilityModifier =
-    modifiersEnabled &&
-    options.modifiers != null &&
-    (options.modifiers === 'any' ||
-      (typeof options.modifiers === 'object' &&
-        ((utilityModifier && isArbitraryValue(utilityModifier)) ||
-          utilityModifier in options.modifiers)))
-
-  if (!canUseUtilityModifier) {
-    modifier = rawModifier
-    utilityModifier = undefined
-  }
-
-  if (utilityModifier !== undefined && modifier === '') {
-    modifier = 'DEFAULT'
-  }
-
-  // Check the full value first
-  // TODO: Move to asValue… somehow
-  if (utilityModifier !== undefined) {
-    if (typeof options.modifiers === 'object') {
-      let configValue = options.modifiers?.[utilityModifier] ?? null
-      if (configValue !== null) {
-        utilityModifier = configValue
-      } else if (isArbitraryValue(utilityModifier)) {
-        utilityModifier = unwrapArbitraryModifier(utilityModifier)
-      }
-    }
-  }
-
-  for (let { type } of types ?? []) {
-    let result = typeMap[type](modifier, options, {
-      tailwindConfig,
-    })
-
-    if (result === undefined) {
-      continue
-    }
-
-    yield [result, type, utilityModifier ?? null]
-  }
-}

package/src/util/prefixSelector.js

@@ -1,33 +0,0 @@
-import parser from 'postcss-selector-parser'
-
-/**
- * @template {string | import('postcss-selector-parser').Root} T
- *
- * Prefix all classes in the selector with the given prefix
- *
- * It can take either a string or a selector AST and will return the same type
- *
- * @param {string} prefix
- * @param {T} selector
- * @param {boolean} prependNegative
- * @returns {T}
- */
-export default function (prefix, selector, prependNegative = false) {
-  if (prefix === '') {
-    return selector
-  }
-
-  /** @type {import('postcss-selector-parser').Root} */
-  let ast = typeof selector === 'string' ? parser().astSync(selector) : selector
-
-  ast.walkClasses((classSelector) => {
-    let baseClass = classSelector.value
-    let shouldPlaceNegativeBeforePrefix = prependNegative && baseClass.startsWith('-')
-
-    classSelector.value = shouldPlaceNegativeBeforePrefix
-      ? `-${prefix}${baseClass.slice(1)}`
-      : `${prefix}${baseClass}`
-  })
-
-  return typeof selector === 'string' ? ast.toString() : ast
-}

package/src/util/pseudoElements.js

@@ -1,167 +0,0 @@
-/** @typedef {import('postcss-selector-parser').Root} Root */
-/** @typedef {import('postcss-selector-parser').Selector} Selector */
-/** @typedef {import('postcss-selector-parser').Pseudo} Pseudo */
-/** @typedef {import('postcss-selector-parser').Node} Node */
-
-// There are some pseudo-elements that may or may not be:
-
-// **Actionable**
-// Zero or more user-action pseudo-classes may be attached to the pseudo-element itself
-// structural-pseudo-classes are NOT allowed but we don't make
-// The spec is not clear on whether this is allowed or not — but in practice it is.
-
-// **Terminal**
-// It MUST be placed at the end of a selector
-//
-// This is the required in the spec. However, some pseudo elements are not "terminal" because
-// they represent a "boundary piercing" that is compiled out by a build step.
-
-// **Jumpable**
-// Any terminal element may "jump" over combinators when moving to the end of the selector
-//
-// This is a backwards-compat quirk of pseudo element variants from earlier versions of Tailwind CSS.
-
-/** @typedef {'terminal' | 'actionable' | 'jumpable'} PseudoProperty */
-
-/** @type {Record<string, PseudoProperty[]>} */
-let elementProperties = {
-  // Pseudo elements from the spec
-  '::after': ['terminal', 'jumpable'],
-  '::backdrop': ['terminal', 'jumpable'],
-  '::before': ['terminal', 'jumpable'],
-  '::cue': ['terminal'],
-  '::cue-region': ['terminal'],
-  '::first-letter': ['terminal', 'jumpable'],
-  '::first-line': ['terminal', 'jumpable'],
-  '::grammar-error': ['terminal'],
-  '::marker': ['terminal', 'jumpable'],
-  '::part': ['terminal', 'actionable'],
-  '::placeholder': ['terminal', 'jumpable'],
-  '::selection': ['terminal', 'jumpable'],
-  '::slotted': ['terminal'],
-  '::spelling-error': ['terminal'],
-  '::target-text': ['terminal'],
-
-  // Pseudo elements from the spec with special rules
-  '::file-selector-button': ['terminal', 'actionable'],
-
-  // Library-specific pseudo elements used by component libraries
-  // These are Shadow DOM-like
-  '::deep': ['actionable'],
-  '::v-deep': ['actionable'],
-  '::ng-deep': ['actionable'],
-
-  // Note: As a rule, double colons (::) should be used instead of a single colon
-  // (:). This distinguishes pseudo-classes from pseudo-elements. However, since
-  // this distinction was not present in older versions of the W3C spec, most
-  // browsers support both syntaxes for the original pseudo-elements.
-  ':after': ['terminal', 'jumpable'],
-  ':before': ['terminal', 'jumpable'],
-  ':first-letter': ['terminal', 'jumpable'],
-  ':first-line': ['terminal', 'jumpable'],
-
-  // The default value is used when the pseudo-element is not recognized
-  // Because it's not recognized, we don't know if it's terminal or not
-  // So we assume it can be moved AND can have user-action pseudo classes attached to it
-  __default__: ['terminal', 'actionable'],
-}
-
-/**
- * @param {Selector} sel
- * @returns {Selector}
- */
-export function movePseudos(sel) {
-  let [pseudos] = movablePseudos(sel)
-
-  // Remove all pseudo elements from their respective selectors
-  pseudos.forEach(([sel, pseudo]) => sel.removeChild(pseudo))
-
-  // Re-add them to the end of the selector in the correct order.
-  // This moves terminal pseudo elements to the end of the
-  // selector otherwise the selector will not be valid.
-  //
-  // Examples:
-  //  - `before:hover:text-center` would result in `.before\:hover\:text-center:hover::before`
-  //  - `hover:before:text-center` would result in `.hover\:before\:text-center:hover::before`
-  //
-  // The selector `::before:hover` does not work but we
-  // can make it work for you by flipping the order.
-  sel.nodes.push(...pseudos.map(([, pseudo]) => pseudo))
-
-  return sel
-}
-
-/** @typedef {[sel: Selector, pseudo: Pseudo, attachedTo: Pseudo | null]} MovablePseudo */
-/** @typedef {[pseudos: MovablePseudo[], lastSeenElement: Pseudo | null]} MovablePseudosResult */
-
-/**
- * @param {Selector} sel
- * @returns {MovablePseudosResult}
- */
-function movablePseudos(sel) {
-  /** @type {MovablePseudo[]} */
-  let buffer = []
-
-  /** @type {Pseudo | null} */
-  let lastSeenElement = null
-
-  for (let node of sel.nodes) {
-    if (node.type === 'combinator') {
-      buffer = buffer.filter(([, node]) => propertiesForPseudo(node).includes('jumpable'))
-      lastSeenElement = null
-    } else if (node.type === 'pseudo') {
-      if (isMovablePseudoElement(node)) {
-        lastSeenElement = node
-        buffer.push([sel, node, null])
-      } else if (lastSeenElement && isAttachablePseudoClass(node, lastSeenElement)) {
-        buffer.push([sel, node, lastSeenElement])
-      } else {
-        lastSeenElement = null
-      }
-
-      for (let sub of node.nodes ?? []) {
-        let [movable, lastSeenElementInSub] = movablePseudos(sub)
-        lastSeenElement = lastSeenElementInSub || lastSeenElement
-        buffer.push(...movable)
-      }
-    }
-  }
-
-  return [buffer, lastSeenElement]
-}
-
-/**
- * @param {Node} node
- * @returns {boolean}
- */
-function isPseudoElement(node) {
-  return node.value.startsWith('::') || elementProperties[node.value] !== undefined
-}
-
-/**
- * @param {Node} node
- * @returns {boolean}
- */
-function isMovablePseudoElement(node) {
-  return isPseudoElement(node) && propertiesForPseudo(node).includes('terminal')
-}
-
-/**
- * @param {Node} node
- * @param {Pseudo} pseudo
- * @returns {boolean}
- */
-function isAttachablePseudoClass(node, pseudo) {
-  if (node.type !== 'pseudo') return false
-  if (isPseudoElement(node)) return false
-
-  return propertiesForPseudo(pseudo).includes('actionable')
-}
-
-/**
- * @param {Pseudo} pseudo
- * @returns {PseudoProperty[]}
- */
-function propertiesForPseudo(pseudo) {
-  return elementProperties[pseudo.value] ?? elementProperties.__default__
-}

package/src/util/removeAlphaVariables.js

@@ -1,24 +0,0 @@
-/**
- * This function removes any uses of CSS variables used as an alpha channel
- *
- * This is required for selectors like `:visited` which do not allow
- * changes in opacity or external control using CSS variables.
- *
- * @param {import('postcss').Container} container
- * @param {string[]} toRemove
- */
-export function removeAlphaVariables(container, toRemove) {
-  container.walkDecls((decl) => {
-    if (toRemove.includes(decl.prop)) {
-      decl.remove()
-
-      return
-    }
-
-    for (let varName of toRemove) {
-      if (decl.value.includes(`/ var(${varName})`)) {
-        decl.value = decl.value.replace(`/ var(${varName})`, '')
-      }
-    }
-  })
-}