tailwindcss 0.0.0-insiders.ebc1c7a → 0.0.0-insiders.ec0049a

package/src/util/createPlugin.js

@@ -1,27 +0,0 @@
-function createPlugin(plugin, config) {
-  return {
-    handler: plugin,
-    config,
-  }
-}
-
-createPlugin.withOptions = function (pluginFunction, configFunction = () => ({})) {
-  const optionsFunction = function (options) {
-    return {
-      __options: options,
-      handler: pluginFunction(options),
-      config: configFunction(options),
-    }
-  }
-
-  optionsFunction.__isOptionsFunction = true
-
-  // Expose plugin dependencies so that `object-hash` returns a different
-  // value if anything here changes, to ensure a rebuild is triggered.
-  optionsFunction.__pluginFunction = pluginFunction
-  optionsFunction.__configFunction = configFunction
-
-  return optionsFunction
-}
-
-export default createPlugin

package/src/util/createUtilityPlugin.js

@@ -1,46 +0,0 @@
-import transformThemeValue from './transformThemeValue'
-import { asValue, asColor, asAngle, asLength, asLookupValue } from '../util/pluginUtils'
-
-let asMap = new Map([
-  [asValue, 'any'],
-  [asColor, 'color'],
-  [asAngle, 'angle'],
-  [asLength, 'length'],
-  [asLookupValue, 'lookup'],
-])
-
-export default function createUtilityPlugin(
-  themeKey,
-  utilityVariations = [[themeKey, [themeKey]]],
-  { filterDefault = false, resolveArbitraryValue = asValue } = {}
-) {
-  let transformValue = transformThemeValue(themeKey)
-  return function ({ matchUtilities, theme }) {
-    for (let utilityVariation of utilityVariations) {
-      let group = Array.isArray(utilityVariation[0]) ? utilityVariation : [utilityVariation]
-
-      matchUtilities(
-        group.reduce((obj, [classPrefix, properties]) => {
-          return Object.assign(obj, {
-            [classPrefix]: (value) => {
-              return properties.reduce((obj, name) => {
-                if (Array.isArray(name)) {
-                  return Object.assign(obj, { [name[0]]: name[1] })
-                }
-                return Object.assign(obj, { [name]: transformValue(value) })
-              }, {})
-            },
-          })
-        }, {}),
-        {
-          values: filterDefault
-            ? Object.fromEntries(
-                Object.entries(theme(themeKey) ?? {}).filter(([modifier]) => modifier !== 'DEFAULT')
-              )
-            : theme(themeKey),
-          type: asMap.get(resolveArbitraryValue) ?? 'any',
-        }
-      )
-    }
-  }
-}

package/src/util/defaults.js

@@ -1,11 +0,0 @@
-export function defaults(target, ...sources) {
-  for (let source of sources) {
-    for (let k in source) {
-      if (!target?.hasOwnProperty?.(k)) {
-        target[k] = source[k]
-      }
-    }
-  }
-
-  return target
-}

package/src/util/escapeClassName.js

@@ -1,8 +0,0 @@
-import parser from 'postcss-selector-parser'
-import escapeCommas from './escapeCommas'
-
-export default function escapeClassName(className) {
-  let node = parser.className()
-  node.value = className
-  return escapeCommas(node?.raws?.value ?? node.value)
-}

package/src/util/escapeCommas.js

@@ -1,3 +0,0 @@
-export default function escapeCommas(className) {
-  return className.replace(/\\,/g, '\\2c ')
-}

package/src/util/flattenColorPalette.js

@@ -1,13 +0,0 @@
-const flattenColorPalette = (colors) =>
-  Object.assign(
-    {},
-    ...Object.entries(colors ?? {}).flatMap(([color, values]) =>
-      typeof values == 'object'
-        ? Object.entries(flattenColorPalette(values)).map(([number, hex]) => ({
-            [color + (number === 'DEFAULT' ? '' : `-${number}`)]: hex,
-          }))
-        : [{ [`${color}`]: values }]
-    )
-  )
-
-export default flattenColorPalette

package/src/util/getAllConfigs.js

@@ -1,19 +0,0 @@
-import defaultConfig from '../../stubs/defaultConfig.stub.js'
-import { flagEnabled } from '../featureFlags'
-
-export default function getAllConfigs(config) {
-  const configs = (config?.presets ?? [defaultConfig])
-    .slice()
-    .reverse()
-    .flatMap((preset) => getAllConfigs(preset instanceof Function ? preset() : preset))
-
-  const features = {
-    // Add experimental configs here...
-  }
-
-  const experimentals = Object.keys(features)
-    .filter((feature) => flagEnabled(config, feature))
-    .map((feature) => features[feature])
-
-  return [config, ...experimentals, ...configs]
-}

package/src/util/hashConfig.js

@@ -1,5 +0,0 @@
-import hash from 'object-hash'
-
-export default function hashConfig(config) {
-  return hash(config, { ignoreUnknown: true })
-}

package/src/util/isKeyframeRule.js

@@ -1,3 +0,0 @@
-export default function isKeyframeRule(rule) {
-  return rule.parent && rule.parent.type === 'atrule' && /keyframes$/.test(rule.parent.name)
-}

package/src/util/isPlainObject.js

@@ -1,8 +0,0 @@
-export default function isPlainObject(value) {
-  if (Object.prototype.toString.call(value) !== '[object Object]') {
-    return false
-  }
-
-  const prototype = Object.getPrototypeOf(value)
-  return prototype === null || prototype === Object.prototype
-}

package/src/util/log.js

@@ -1,28 +0,0 @@
-import chalk from 'chalk'
-
-export default {
-  info(messages) {
-    if (process.env.JEST_WORKER_ID !== undefined) return
-
-    console.warn('')
-    messages.forEach((message) => {
-      console.warn(chalk.bold.cyan('info'), '-', message)
-    })
-  },
-  warn(messages) {
-    if (process.env.JEST_WORKER_ID !== undefined) return
-
-    console.warn('')
-    messages.forEach((message) => {
-      console.warn(chalk.bold.yellow('warn'), '-', message)
-    })
-  },
-  risk(messages) {
-    if (process.env.JEST_WORKER_ID !== undefined) return
-
-    console.warn('')
-    messages.forEach((message) => {
-      console.warn(chalk.bold.magenta('risk'), '-', message)
-    })
-  },
-}

package/src/util/nameClass.js

@@ -1,22 +0,0 @@
-import escapeClassName from './escapeClassName'
-import escapeCommas from './escapeCommas'
-
-function asClass(name) {
-  return escapeCommas(`.${escapeClassName(name)}`)
-}
-
-export default function nameClass(classPrefix, key) {
-  if (key === 'DEFAULT') {
-    return asClass(classPrefix)
-  }
-
-  if (key === '-') {
-    return asClass(`-${classPrefix}`)
-  }
-
-  if (key.startsWith('-')) {
-    return asClass(`-${classPrefix}${key}`)
-  }
-
-  return asClass(`${classPrefix}-${key}`)
-}

package/src/util/negateValue.js

@@ -1,14 +0,0 @@
-export default function (value) {
-  value = `${value}`
-
-  // Flip sign of numbers
-  if (/^[+-]?(\d+|\d*\.\d+)(e[+-]?\d+)?(%|\w+)?$/.test(value)) {
-    return value.replace(/^[+-]?/, (sign) => (sign === '-' ? '' : '-'))
-  }
-
-  if (value.includes('var(') || value.includes('calc(')) {
-    return `calc(${value} * -1)`
-  }
-
-  return value
-}

package/src/util/parseAnimationValue.js

@@ -1,62 +0,0 @@
-const DIRECTIONS = new Set(['normal', 'reverse', 'alternate', 'alternate-reverse'])
-const PLAY_STATES = new Set(['running', 'paused'])
-const FILL_MODES = new Set(['none', 'forwards', 'backwards', 'both'])
-const ITERATION_COUNTS = new Set(['infinite'])
-const TIMINGS = new Set([
-  'linear',
-  'ease',
-  'ease-in',
-  'ease-out',
-  'ease-in-out',
-  'step-start',
-  'step-end',
-])
-const TIMING_FNS = ['cubic-bezier', 'steps']
-
-const COMMA = /\,(?![^(]*\))/g // Comma separator that is not located between brackets. E.g.: `cubiz-bezier(a, b, c)` these don't count.
-const SPACE = /\ +(?![^(]*\))/g // Similar to the one above, but with spaces instead.
-const TIME = /^(-?[\d.]+m?s)$/
-const DIGIT = /^(\d+)$/
-
-export default function parseAnimationValue(input) {
-  let animations = input.split(COMMA)
-  return animations.map((animation) => {
-    let value = animation.trim()
-    let result = { value }
-    let parts = value.split(SPACE)
-    let seen = new Set()
-
-    for (let part of parts) {
-      if (!seen.has('DIRECTIONS') && DIRECTIONS.has(part)) {
-        result.direction = part
-        seen.add('DIRECTIONS')
-      } else if (!seen.has('PLAY_STATES') && PLAY_STATES.has(part)) {
-        result.playState = part
-        seen.add('PLAY_STATES')
-      } else if (!seen.has('FILL_MODES') && FILL_MODES.has(part)) {
-        result.fillMode = part
-        seen.add('FILL_MODES')
-      } else if (
-        !seen.has('ITERATION_COUNTS') &&
-        (ITERATION_COUNTS.has(part) || DIGIT.test(part))
-      ) {
-        result.iterationCount = part
-        seen.add('ITERATION_COUNTS')
-      } else if (!seen.has('TIMING_FUNCTION') && TIMINGS.has(part)) {
-        result.timingFunction = part
-        seen.add('TIMING_FUNCTION')
-      } else if (!seen.has('TIMING_FUNCTION') && TIMING_FNS.some((f) => part.startsWith(`${f}(`))) {
-        result.timingFunction = part
-        seen.add('TIMING_FUNCTION')
-      } else if (!seen.has('DURATION') && TIME.test(part)) {
-        result.duration = part
-        seen.add('DURATION')
-      } else if (!seen.has('DELAY') && TIME.test(part)) {
-        result.delay = part
-        seen.add('DELAY')
-      } else result.name = part
-    }
-
-    return result
-  })
-}

package/src/util/parseDependency.js

@@ -1,45 +0,0 @@
-import isGlob from 'is-glob'
-import globParent from 'glob-parent'
-import path from 'path'
-
-// Based on `glob-base`
-// https://github.com/micromatch/glob-base/blob/master/index.js
-function parseGlob(pattern) {
-  let glob = pattern
-  let base = globParent(pattern)
-
-  if (base !== '.') {
-    glob = pattern.substr(base.length)
-    if (glob.charAt(0) === '/') {
-      glob = glob.substr(1)
-    }
-  }
-
-  if (glob.substr(0, 2) === './') {
-    glob = glob.substr(2)
-  }
-  if (glob.charAt(0) === '/') {
-    glob = glob.substr(1)
-  }
-
-  return { base, glob }
-}
-
-export default function parseDependency(normalizedFileOrGlob) {
-  let message
-
-  if (isGlob(normalizedFileOrGlob)) {
-    let { base, glob } = parseGlob(normalizedFileOrGlob)
-    message = { type: 'dir-dependency', dir: path.resolve(base), glob }
-  } else {
-    message = { type: 'dependency', file: path.resolve(normalizedFileOrGlob) }
-  }
-
-  // rollup-plugin-postcss does not support dir-dependency messages
-  // but directories can be watched in the same way as files
-  if (message.type === 'dir-dependency' && process.env.ROLLUP_WATCH === 'true') {
-    message = { type: 'dependency', file: message.dir }
-  }
-
-  return message
-}

package/src/util/parseObjectStyles.js

@@ -1,19 +0,0 @@
-import postcss from 'postcss'
-import postcssNested from 'postcss-nested'
-import postcssJs from 'postcss-js'
-
-export default function parseObjectStyles(styles) {
-  if (!Array.isArray(styles)) {
-    return parseObjectStyles([styles])
-  }
-
-  return styles.flatMap((style) => {
-    return postcss([
-      postcssNested({
-        bubble: ['screen'],
-      }),
-    ]).process(style, {
-      parser: postcssJs,
-    }).root.nodes
-  })
-}

package/src/util/pluginUtils.js

@@ -1,295 +0,0 @@
-import selectorParser from 'postcss-selector-parser'
-import escapeCommas from './escapeCommas'
-import { withAlphaValue } from './withAlphaVariable'
-import isKeyframeRule from './isKeyframeRule'
-import { parseColor } from './color'
-
-export function applyPseudoToMarker(selector, marker, state, join) {
-  let states = [state]
-
-  let markerIdx = selector.indexOf(marker + ':')
-
-  if (markerIdx !== -1) {
-    let existingMarker = selector.slice(markerIdx, selector.indexOf(' ', markerIdx))
-
-    states = states.concat(
-      selector.slice(markerIdx + marker.length + 1, existingMarker.length).split(':')
-    )
-
-    selector = selector.replace(existingMarker, '')
-  }
-
-  return join(`${[marker, ...states].join(':')}`, selector)
-}
-
-export function updateAllClasses(selectors, updateClass) {
-  let parser = selectorParser((selectors) => {
-    selectors.walkClasses((sel) => {
-      let updatedClass = updateClass(sel.value, {
-        withPseudo(className, pseudo) {
-          sel.parent.insertAfter(sel, selectorParser.pseudo({ value: `${pseudo}` }))
-          return className
-        },
-      })
-      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 updateLastClasses(selectors, updateClass) {
-  let parser = selectorParser((selectors) => {
-    selectors.each((sel) => {
-      let lastClass = sel.filter(({ type }) => type === 'class').pop()
-
-      if (lastClass === undefined) {
-        return
-      }
-
-      let updatedClass = updateClass(lastClass.value, {
-        withPseudo(className, pseudo) {
-          lastClass.parent.insertAfter(lastClass, selectorParser.pseudo({ value: `${pseudo}` }))
-          return className
-        },
-      })
-      lastClass.value = updatedClass
-      if (lastClass.raws && lastClass.raws.value) {
-        lastClass.raws.value = escapeCommas(lastClass.raws.value)
-      }
-    })
-  })
-  let result = parser.processSync(selectors)
-
-  return result
-}
-
-function splitByNotEscapedCommas(str) {
-  let chunks = []
-  let currentChunk = ''
-  for (let i = 0; i < str.length; i++) {
-    if (str[i] === ',' && str[i - 1] !== '\\') {
-      chunks.push(currentChunk)
-      currentChunk = ''
-    } else {
-      currentChunk += str[i]
-    }
-  }
-  chunks.push(currentChunk)
-  return chunks
-}
-
-export function transformAllSelectors(transformSelector, { wrap, withRule } = {}) {
-  return ({ container }) => {
-    container.walkRules((rule) => {
-      if (isKeyframeRule(rule)) {
-        return rule
-      }
-      let transformed = splitByNotEscapedCommas(rule.selector).map(transformSelector).join(',')
-      rule.selector = transformed
-      if (withRule) {
-        withRule(rule)
-      }
-      return rule
-    })
-
-    if (wrap) {
-      let wrapper = wrap()
-      let nodes = container.nodes
-      container.removeAll()
-      wrapper.append(nodes)
-      container.append(wrapper)
-    }
-  }
-}
-
-export function transformAllClasses(transformClass, { wrap, withRule } = {}) {
-  return ({ container }) => {
-    container.walkRules((rule) => {
-      let selector = rule.selector
-      let variantSelector = updateAllClasses(selector, transformClass)
-      rule.selector = variantSelector
-      if (withRule) {
-        withRule(rule)
-      }
-      return rule
-    })
-
-    if (wrap) {
-      let wrapper = wrap()
-      let nodes = container.nodes
-      container.removeAll()
-      wrapper.append(nodes)
-      container.append(wrapper)
-    }
-  }
-}
-
-export function transformLastClasses(transformClass, { wrap, withRule } = {}) {
-  return ({ container }) => {
-    container.walkRules((rule) => {
-      let selector = rule.selector
-      let variantSelector = updateLastClasses(selector, transformClass)
-      rule.selector = variantSelector
-      if (withRule) {
-        withRule(rule)
-      }
-      return rule
-    })
-
-    if (wrap) {
-      let wrapper = wrap()
-      let nodes = container.nodes
-      container.removeAll()
-      wrapper.append(nodes)
-      container.append(wrapper)
-    }
-  }
-}
-
-export function asValue(modifier, lookup = {}, { validate = () => true } = {}) {
-  let value = lookup[modifier]
-
-  if (value !== undefined) {
-    return value
-  }
-
-  if (modifier[0] !== '[' || modifier[modifier.length - 1] !== ']') {
-    return undefined
-  }
-
-  value = modifier.slice(1, -1)
-
-  if (!validate(value)) {
-    return undefined
-  }
-
-  // convert `_` to ` `, escept for escaped underscores `\_`
-  value = value
-    .replace(/([^\\])_/g, '$1 ')
-    .replace(/^_/g, ' ')
-    .replace(/\\_/g, '_')
-
-  // add spaces around operators inside calc() that do not follow an operator or (
-  return value.replace(
-    /(-?\d*\.?\d(?!\b-.+[,)](?![^+\-/*])\D)(?:%|[a-z]+)?|\))([+\-/*])/g,
-    '$1 $2 '
-  )
-}
-
-export function asUnit(modifier, units, lookup = {}) {
-  return asValue(modifier, lookup, {
-    validate: (value) => {
-      let unitsPattern = `(?:${units.join('|')})`
-      return (
-        new RegExp(`${unitsPattern}$`).test(value) ||
-        new RegExp(`^calc\\(.+?${unitsPattern}`).test(value)
-      )
-    },
-  })
-}
-
-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, lookup = {}, tailwindConfig = {}) {
-  if (lookup[modifier] !== undefined) {
-    return lookup[modifier]
-  }
-
-  let [color, alpha] = splitAlpha(modifier)
-
-  if (lookup[color] !== undefined) {
-    if (isArbitraryValue(alpha)) {
-      return withAlphaValue(lookup[color], alpha.slice(1, -1))
-    }
-
-    if (tailwindConfig.theme?.opacity?.[alpha] === undefined) {
-      return undefined
-    }
-
-    return withAlphaValue(lookup[color], tailwindConfig.theme.opacity[alpha])
-  }
-
-  return asValue(modifier, lookup, {
-    validate: (value) => parseColor(value) !== null,
-  })
-}
-
-export function asAngle(modifier, lookup = {}) {
-  return asUnit(modifier, ['deg', 'grad', 'rad', 'turn'], lookup)
-}
-
-export function asLength(modifier, lookup = {}) {
-  return asUnit(
-    modifier,
-    [
-      'cm',
-      'mm',
-      'Q',
-      'in',
-      'pc',
-      'pt',
-      'px',
-      'em',
-      'ex',
-      'ch',
-      'rem',
-      'lh',
-      'vw',
-      'vh',
-      'vmin',
-      'vmax',
-      '%',
-    ],
-    lookup
-  )
-}
-
-export function asLookupValue(modifier, lookup = {}) {
-  return lookup[modifier]
-}
-
-let typeMap = {
-  any: asValue,
-  color: asColor,
-  angle: asAngle,
-  length: asLength,
-  lookup: asLookupValue,
-}
-
-function splitAtFirst(input, delim) {
-  return (([first, ...rest]) => [first, rest.join(delim)])(input.split(delim))
-}
-
-export function coerceValue(type, modifier, values, tailwindConfig) {
-  let [scaleType, arbitraryType = scaleType] = [].concat(type)
-
-  if (isArbitraryValue(modifier)) {
-    let [explicitType, value] = splitAtFirst(modifier.slice(1, -1), ':')
-
-    if (value.length > 0 && Object.keys(typeMap).includes(explicitType)) {
-      return [asValue(`[${value}]`, values, tailwindConfig), explicitType]
-    }
-
-    return [typeMap[arbitraryType](modifier, values, tailwindConfig), arbitraryType]
-  }
-
-  return [typeMap[scaleType](modifier, values, tailwindConfig), scaleType]
-}

package/src/util/prefixSelector.js

@@ -1,15 +0,0 @@
-import parser from 'postcss-selector-parser'
-import { tap } from './tap'
-
-export default function (prefix, selector) {
-  const getPrefix =
-    typeof prefix === 'function' ? prefix : () => (prefix === undefined ? '' : prefix)
-
-  return parser((selectors) => {
-    selectors.walkClasses((classSelector) => {
-      tap(classSelector.value, (baseClass) => {
-        classSelector.value = `${getPrefix('.' + baseClass)}${baseClass}`
-      })
-    })
-  }).processSync(selector)
-}