tailwindcss 0.0.0-insiders.ff2c25f → 0.0.0-internal.b2586d4e

package/src/util/pluginUtils.js

@@ -1,314 +0,0 @@
-import selectorParser from 'postcss-selector-parser'
-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'
-
-export function updateAllClasses(selectors, updateClass) {
-  let parser = selectorParser((selectors) => {
-    selectors.walkClasses((sel) => {
-      let updatedClass = updateClass(sel.value)
-      sel.value = updatedClass
-      if (sel.raws && sel.raws.value) {
-        sel.raws.value = escapeCommas(sel.raws.value)
-      }
-    })
-  })
-
-  let result = parser.processSync(selectors)
-
-  return result
-}
-
-export function filterSelectorsForClass(selectors, classCandidate) {
-  let parser = selectorParser((selectors) => {
-    selectors.each((sel) => {
-      const containsClass = sel.nodes.some(
-        (node) => node.type === 'class' && node.value === classCandidate
-      )
-      if (!containsClass) {
-        sel.remove()
-      }
-    })
-  })
-
-  let result = parser.processSync(selectors)
-
-  return result
-}
-
-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 (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) {
-  modifier = modifier.slice(1, -1)
-  if (modifier.startsWith('--')) {
-    modifier = `var(${modifier})`
-  }
-  return modifier
-}
-
-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,32 +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
-  }
-
-  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/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})`, '')
-      }
-    }
-  })
-}

package/src/util/resolveConfig.js

@@ -1,277 +0,0 @@
-import negateValue from './negateValue'
-import corePluginList from '../corePluginList'
-import configurePlugins from './configurePlugins'
-import colors from '../public/colors'
-import { defaults } from './defaults'
-import { toPath } from './toPath'
-import { normalizeConfig } from './normalizeConfig'
-import isPlainObject from './isPlainObject'
-import { cloneDeep } from './cloneDeep'
-import { parseColorFormat } from './pluginUtils'
-import { withAlphaValue } from './withAlphaVariable'
-import toColorValue from './toColorValue'
-
-function isFunction(input) {
-  return typeof input === 'function'
-}
-
-function mergeWith(target, ...sources) {
-  let customizer = sources.pop()
-
-  for (let source of sources) {
-    for (let k in source) {
-      let merged = customizer(target[k], source[k])
-
-      if (merged === undefined) {
-        if (isPlainObject(target[k]) && isPlainObject(source[k])) {
-          target[k] = mergeWith({}, target[k], source[k], customizer)
-        } else {
-          target[k] = source[k]
-        }
-      } else {
-        target[k] = merged
-      }
-    }
-  }
-
-  return target
-}
-
-const configUtils = {
-  colors,
-  negative(scale) {
-    // TODO: Log that this function isn't really needed anymore?
-    return Object.keys(scale)
-      .filter((key) => scale[key] !== '0')
-      .reduce((negativeScale, key) => {
-        let negativeValue = negateValue(scale[key])
-
-        if (negativeValue !== undefined) {
-          negativeScale[`-${key}`] = negativeValue
-        }
-
-        return negativeScale
-      }, {})
-  },
-  breakpoints(screens) {
-    return Object.keys(screens)
-      .filter((key) => typeof screens[key] === 'string')
-      .reduce(
-        (breakpoints, key) => ({
-          ...breakpoints,
-          [`screen-${key}`]: screens[key],
-        }),
-        {}
-      )
-  },
-}
-
-function value(valueToResolve, ...args) {
-  return isFunction(valueToResolve) ? valueToResolve(...args) : valueToResolve
-}
-
-function collectExtends(items) {
-  return items.reduce((merged, { extend }) => {
-    return mergeWith(merged, extend, (mergedValue, extendValue) => {
-      if (mergedValue === undefined) {
-        return [extendValue]
-      }
-
-      if (Array.isArray(mergedValue)) {
-        return [extendValue, ...mergedValue]
-      }
-
-      return [extendValue, mergedValue]
-    })
-  }, {})
-}
-
-function mergeThemes(themes) {
-  return {
-    ...themes.reduce((merged, theme) => defaults(merged, theme), {}),
-
-    // In order to resolve n config objects, we combine all of their `extend` properties
-    // into arrays instead of objects so they aren't overridden.
-    extend: collectExtends(themes),
-  }
-}
-
-function mergeExtensionCustomizer(merged, value) {
-  // When we have an array of objects, we do want to merge it
-  if (Array.isArray(merged) && isPlainObject(merged[0])) {
-    return merged.concat(value)
-  }
-
-  // When the incoming value is an array, and the existing config is an object, prepend the existing object
-  if (Array.isArray(value) && isPlainObject(value[0]) && isPlainObject(merged)) {
-    return [merged, ...value]
-  }
-
-  // Override arrays (for example for font-families, box-shadows, ...)
-  if (Array.isArray(value)) {
-    return value
-  }
-
-  // Execute default behaviour
-  return undefined
-}
-
-function mergeExtensions({ extend, ...theme }) {
-  return mergeWith(theme, extend, (themeValue, extensions) => {
-    // The `extend` property is an array, so we need to check if it contains any functions
-    if (!isFunction(themeValue) && !extensions.some(isFunction)) {
-      return mergeWith({}, themeValue, ...extensions, mergeExtensionCustomizer)
-    }
-
-    return (resolveThemePath, utils) =>
-      mergeWith(
-        {},
-        ...[themeValue, ...extensions].map((e) => value(e, resolveThemePath, utils)),
-        mergeExtensionCustomizer
-      )
-  })
-}
-
-/**
- *
- * @param {string} key
- * @return {Iterable<string[] & {alpha: string | undefined}>}
- */
-function* toPaths(key) {
-  let path = toPath(key)
-
-  if (path.length === 0) {
-    return
-  }
-
-  yield path
-
-  if (Array.isArray(key)) {
-    return
-  }
-
-  let pattern = /^(.*?)\s*\/\s*([^/]+)$/
-  let matches = key.match(pattern)
-
-  if (matches !== null) {
-    let [, prefix, alpha] = matches
-
-    let newPath = toPath(prefix)
-    newPath.alpha = alpha
-
-    yield newPath
-  }
-}
-
-function resolveFunctionKeys(object) {
-  // theme('colors.red.500 / 0.5') -> ['colors', 'red', '500 / 0', '5]
-
-  const resolvePath = (key, defaultValue) => {
-    for (const path of toPaths(key)) {
-      let index = 0
-      let val = object
-
-      while (val !== undefined && val !== null && index < path.length) {
-        val = val[path[index++]]
-
-        let shouldResolveAsFn =
-          isFunction(val) && (path.alpha === undefined || index <= path.length - 1)
-
-        val = shouldResolveAsFn ? val(resolvePath, configUtils) : val
-      }
-
-      if (val !== undefined) {
-        if (path.alpha !== undefined) {
-          let normalized = parseColorFormat(val)
-
-          return withAlphaValue(normalized, path.alpha, toColorValue(normalized))
-        }
-
-        if (isPlainObject(val)) {
-          return cloneDeep(val)
-        }
-
-        return val
-      }
-    }
-
-    return defaultValue
-  }
-
-  Object.assign(resolvePath, {
-    theme: resolvePath,
-    ...configUtils,
-  })
-
-  return Object.keys(object).reduce((resolved, key) => {
-    resolved[key] = isFunction(object[key]) ? object[key](resolvePath, configUtils) : object[key]
-
-    return resolved
-  }, {})
-}
-
-function extractPluginConfigs(configs) {
-  let allConfigs = []
-
-  configs.forEach((config) => {
-    allConfigs = [...allConfigs, config]
-
-    const plugins = config?.plugins ?? []
-
-    if (plugins.length === 0) {
-      return
-    }
-
-    plugins.forEach((plugin) => {
-      if (plugin.__isOptionsFunction) {
-        plugin = plugin()
-      }
-      allConfigs = [...allConfigs, ...extractPluginConfigs([plugin?.config ?? {}])]
-    })
-  })
-
-  return allConfigs
-}
-
-function resolveCorePlugins(corePluginConfigs) {
-  const result = [...corePluginConfigs].reduceRight((resolved, corePluginConfig) => {
-    if (isFunction(corePluginConfig)) {
-      return corePluginConfig({ corePlugins: resolved })
-    }
-    return configurePlugins(corePluginConfig, resolved)
-  }, corePluginList)
-
-  return result
-}
-
-function resolvePluginLists(pluginLists) {
-  const result = [...pluginLists].reduceRight((resolved, pluginList) => {
-    return [...resolved, ...pluginList]
-  }, [])
-
-  return result
-}
-
-export default function resolveConfig(configs) {
-  let allConfigs = [
-    ...extractPluginConfigs(configs),
-    {
-      prefix: '',
-      important: false,
-      separator: ':',
-    },
-  ]
-
-  return normalizeConfig(
-    defaults(
-      {
-        theme: resolveFunctionKeys(
-          mergeExtensions(mergeThemes(allConfigs.map((t) => t?.theme ?? {})))
-        ),
-        corePlugins: resolveCorePlugins(allConfigs.map((c) => c.corePlugins)),
-        plugins: resolvePluginLists(configs.map((c) => c?.plugins ?? [])),
-      },
-      ...allConfigs
-    )
-  )
-}

package/src/util/resolveConfigPath.js

@@ -1,55 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-
-function isObject(value) {
-  return typeof value === 'object' && value !== null
-}
-
-function isEmpty(obj) {
-  return Object.keys(obj).length === 0
-}
-
-function isString(value) {
-  return typeof value === 'string' || value instanceof String
-}
-
-export default function resolveConfigPath(pathOrConfig) {
-  // require('tailwindcss')({ theme: ..., variants: ... })
-  if (isObject(pathOrConfig) && pathOrConfig.config === undefined && !isEmpty(pathOrConfig)) {
-    return null
-  }
-
-  // require('tailwindcss')({ config: 'custom-config.js' })
-  if (
-    isObject(pathOrConfig) &&
-    pathOrConfig.config !== undefined &&
-    isString(pathOrConfig.config)
-  ) {
-    return path.resolve(pathOrConfig.config)
-  }
-
-  // require('tailwindcss')({ config: { theme: ..., variants: ... } })
-  if (
-    isObject(pathOrConfig) &&
-    pathOrConfig.config !== undefined &&
-    isObject(pathOrConfig.config)
-  ) {
-    return null
-  }
-
-  // require('tailwindcss')('custom-config.js')
-  if (isString(pathOrConfig)) {
-    return path.resolve(pathOrConfig)
-  }
-
-  // require('tailwindcss')
-  for (const configFile of ['./tailwind.config.js', './tailwind.config.cjs']) {
-    try {
-      const configPath = path.resolve(configFile)
-      fs.accessSync(configPath)
-      return configPath
-    } catch (err) {}
-  }
-
-  return null
-}

package/src/util/responsive.js

@@ -1,10 +0,0 @@
-import postcss from 'postcss'
-import cloneNodes from './cloneNodes'
-
-export default function responsive(rules) {
-  return postcss
-    .atRule({
-      name: 'responsive',
-    })
-    .append(cloneNodes(Array.isArray(rules) ? rules : [rules]))
-}