tailwindcss 0.0.0-insiders.bbafc8e → 0.0.0-insiders.bbc2f3f

package/src/util/pluginUtils.js

@@ -1,192 +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'
-
-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
-}
-
-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 splitAlpha(modifier) {
-  let slashIdx = modifier.lastIndexOf('/')
-
-  if (slashIdx === -1 || slashIdx === modifier.length - 1) {
-    return [modifier]
-  }
-
-  return [modifier.slice(0, slashIdx), modifier.slice(slashIdx + 1)]
-}
-
-export function asColor(modifier, options = {}, { tailwindConfig = {} } = {}) {
-  if (options.values?.[modifier] !== undefined) {
-    return options.values?.[modifier]
-  }
-
-  let [color, alpha] = splitAlpha(modifier)
-
-  if (alpha !== undefined) {
-    let normalizedColor =
-      options.values?.[color] ?? (isArbitraryValue(color) ? color.slice(1, -1) : undefined)
-
-    if (normalizedColor === undefined) {
-      return undefined
-    }
-
-    if (isArbitraryValue(alpha)) {
-      return withAlphaValue(normalizedColor, alpha.slice(1, -1))
-    }
-
-    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 })
-  }
-}
-
-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),
-}
-
-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 (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]
-    }
-  }
-
-  // Find first matching type
-  for (let type of [].concat(types)) {
-    let result = typeMap[type](modifier, options, { tailwindConfig })
-    if (result !== undefined) return [result, type]
-  }
-
-  return []
-}

package/src/util/prefixSelector.js

@@ -1,14 +0,0 @@
-import parser from 'postcss-selector-parser'
-
-export default function (prefix, selector, prependNegative = false) {
-  return parser((selectors) => {
-    selectors.walkClasses((classSelector) => {
-      let baseClass = classSelector.value
-      let shouldPlaceNegativeBeforePrefix = prependNegative && baseClass.startsWith('-')
-
-      classSelector.value = shouldPlaceNegativeBeforePrefix
-        ? `-${prefix}${baseClass.slice(1)}`
-        : `${prefix}${baseClass}`
-    })
-  }).processSync(selector)
-}

package/src/util/resolveConfig.js

@@ -1,269 +0,0 @@
-import negateValue from './negateValue'
-import corePluginList from '../corePluginList'
-import configurePlugins from './configurePlugins'
-import defaultConfig from '../../stubs/defaultConfig.stub'
-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'
-
-function isFunction(input) {
-  return typeof input === 'function'
-}
-
-function isObject(input) {
-  return typeof input === 'object' && input !== null
-}
-
-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 (isObject(target[k]) && isObject(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],
-        }),
-        {}
-      )
-  },
-  rgb(property) {
-    if (!property.startsWith('--')) {
-      throw new Error(
-        'The rgb() helper requires a custom property name to be passed as the first argument.'
-      )
-    }
-
-    return ({ opacityValue }) => {
-      if (opacityValue === undefined || opacityValue === 1) {
-        return `rgb(var(${property}) / 1.0)`
-      }
-
-      return `rgb(var(${property}) / ${opacityValue})`
-    }
-  },
-  hsl(property) {
-    if (!property.startsWith('--')) {
-      throw new Error(
-        'The hsl() helper requires a custom property name to be passed as the first argument.'
-      )
-    }
-
-    return ({ opacityValue }) => {
-      if (opacityValue === undefined || opacityValue === 1) {
-        return `hsl(var(${property}) / 1)`
-      }
-
-      return `hsl(var(${property}) / ${opacityValue})`
-    }
-  },
-}
-
-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) && isObject(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) && isObject(value[0]) && isObject(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
-      )
-  })
-}
-
-function resolveFunctionKeys(object) {
-  const resolvePath = (key, defaultValue) => {
-    const path = toPath(key)
-
-    let index = 0
-    let val = object
-
-    while (val !== undefined && val !== null && index < path.length) {
-      val = val[path[index++]]
-      val = isFunction(val) ? val(resolvePath, configUtils) : val
-    }
-
-    if (val === undefined) {
-      return defaultValue
-    }
-
-    if (isPlainObject(val)) {
-      return cloneDeep(val)
-    }
-
-    return val
-  }
-
-  resolvePath.theme = resolvePath
-
-  for (let key in configUtils) {
-    resolvePath[key] = configUtils[key]
-  }
-
-  return Object.keys(object).reduce((resolved, key) => {
-    return {
-      ...resolved,
-      [key]: isFunction(object[key]) ? object[key](resolvePath, configUtils) : object[key],
-    }
-  }, {})
-}
-
-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: ':',
-      variantOrder: defaultConfig.variantOrder,
-    },
-  ]
-
-  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]))
-}

package/src/util/tap.js

@@ -1,4 +0,0 @@
-export function tap(value, mutator) {
-  mutator(value)
-  return value
-}

package/src/util/toColorValue.js

@@ -1,3 +0,0 @@
-export default function toColorValue(maybeFunction) {
-  return typeof maybeFunction === 'function' ? maybeFunction({}) : maybeFunction
-}

package/src/util/toPath.js

@@ -1,26 +0,0 @@
-/**
- * Parse a path string into an array of path segments.
- *
- * Square bracket notation `a[b]` may be used to "escape" dots that would otherwise be interpreted as path separators.
- *
- * Example:
- * a -> ['a]
- * a.b.c -> ['a', 'b', 'c']
- * a[b].c -> ['a', 'b', 'c']
- * a[b.c].e.f -> ['a', 'b.c', 'e', 'f']
- * a[b][c][d] -> ['a', 'b', 'c', 'd']
- *
- * @param {string|string[]} path
- **/
-export function toPath(path) {
-  if (Array.isArray(path)) return path
-
-  let openBrackets = path.split('[').length - 1
-  let closedBrackets = path.split(']').length - 1
-
-  if (openBrackets !== closedBrackets) {
-    throw new Error(`Path is invalid. Has unbalanced brackets: ${path}`)
-  }
-
-  return path.split(/\.(?![^\[]*\])|[\[\]]/g).filter(Boolean)
-}

package/src/util/transformThemeValue.js

@@ -1,52 +0,0 @@
-import postcss from 'postcss'
-
-export default function transformThemeValue(themeSection) {
-  if (['fontSize', 'outline'].includes(themeSection)) {
-    return (value) => {
-      if (typeof value === 'function') value = value({})
-      if (Array.isArray(value)) value = value[0]
-
-      return value
-    }
-  }
-
-  if (
-    [
-      'fontFamily',
-      'boxShadow',
-      'transitionProperty',
-      'transitionDuration',
-      'transitionDelay',
-      'transitionTimingFunction',
-      'backgroundImage',
-      'backgroundSize',
-      'backgroundColor',
-      'cursor',
-      'animation',
-    ].includes(themeSection)
-  ) {
-    return (value) => {
-      if (typeof value === 'function') value = value({})
-      if (Array.isArray(value)) value = value.join(', ')
-
-      return value
-    }
-  }
-
-  // For backwards compatibility reasons, before we switched to underscores
-  // instead of commas for arbitrary values.
-  if (['gridTemplateColumns', 'gridTemplateRows', 'objectPosition'].includes(themeSection)) {
-    return (value) => {
-      if (typeof value === 'function') value = value({})
-      if (typeof value === 'string') value = postcss.list.comma(value).join(' ')
-
-      return value
-    }
-  }
-
-  return (value) => {
-    if (typeof value === 'function') value = value({})
-
-    return value
-  }
-}

package/src/util/withAlphaVariable.js

@@ -1,49 +0,0 @@
-import { parseColor, formatColor } from './color'
-
-export function withAlphaValue(color, alphaValue, defaultValue) {
-  if (typeof color === 'function') {
-    return color({ opacityValue: alphaValue })
-  }
-
-  let parsed = parseColor(color)
-
-  if (parsed === null) {
-    return defaultValue
-  }
-
-  return formatColor({ ...parsed, alpha: alphaValue })
-}
-
-export default function withAlphaVariable({ color, property, variable }) {
-  let properties = [].concat(property)
-  if (typeof color === 'function') {
-    return {
-      [variable]: '1',
-      ...Object.fromEntries(
-        properties.map((p) => {
-          return [p, color({ opacityVariable: variable, opacityValue: `var(${variable})` })]
-        })
-      ),
-    }
-  }
-
-  const parsed = parseColor(color)
-
-  if (parsed === null) {
-    return Object.fromEntries(properties.map((p) => [p, color]))
-  }
-
-  if (parsed.alpha !== undefined) {
-    // Has an alpha value, return color as-is
-    return Object.fromEntries(properties.map((p) => [p, color]))
-  }
-
-  return {
-    [variable]: '1',
-    ...Object.fromEntries(
-      properties.map((p) => {
-        return [p, formatColor({ ...parsed, alpha: `var(${variable})` })]
-      })
-    ),
-  }
-}