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

package/src/util/normalizeConfig.js

@@ -1,270 +0,0 @@
-import log, { dim } from './log'
-
-export function normalizeConfig(config) {
-  // Quick structure validation
-  /**
-   * type FilePath = string
-   * type RawFile = { raw: string, extension?: string }
-   * type ExtractorFn = (content: string) => Array<string>
-   * type TransformerFn = (content: string) => string
-   *
-   * type Content =
-   *   | Array<FilePath | RawFile>
-   *   | {
-   *       files: Array<FilePath | RawFile>,
-   *       extract?: ExtractorFn | { [extension: string]: ExtractorFn }
-   *       transform?: TransformerFn | { [extension: string]: TransformerFn }
-   *   }
-   */
-  let valid = (() => {
-    // `config.purge` should not exist anymore
-    if (config.purge) {
-      return false
-    }
-
-    // `config.content` should exist
-    if (!config.content) {
-      return false
-    }
-
-    // `config.content` should be an object or an array
-    if (
-      !Array.isArray(config.content) &&
-      !(typeof config.content === 'object' && config.content !== null)
-    ) {
-      return false
-    }
-
-    // When `config.content` is an array, it should consist of FilePaths or RawFiles
-    if (Array.isArray(config.content)) {
-      return config.content.every((path) => {
-        // `path` can be a string
-        if (typeof path === 'string') return true
-
-        // `path` can be an object { raw: string, extension?: string }
-        // `raw` must be a string
-        if (typeof path?.raw !== 'string') return false
-
-        // `extension` (if provided) should also be a string
-        if (path?.extension && typeof path?.extension !== 'string') {
-          return false
-        }
-
-        return true
-      })
-    }
-
-    // When `config.content` is an object
-    if (typeof config.content === 'object' && config.content !== null) {
-      // Only `files`, `extract` and `transform` can exist in `config.content`
-      if (
-        Object.keys(config.content).some((key) => !['files', 'extract', 'transform'].includes(key))
-      ) {
-        return false
-      }
-
-      // `config.content.files` should exist of FilePaths or RawFiles
-      if (Array.isArray(config.content.files)) {
-        if (
-          !config.content.files.every((path) => {
-            // `path` can be a string
-            if (typeof path === 'string') return true
-
-            // `path` can be an object { raw: string, extension?: string }
-            // `raw` must be a string
-            if (typeof path?.raw !== 'string') return false
-
-            // `extension` (if provided) should also be a string
-            if (path?.extension && typeof path?.extension !== 'string') {
-              return false
-            }
-
-            return true
-          })
-        ) {
-          return false
-        }
-
-        // `config.content.extract` is optional, and can be a Function or a Record<String, Function>
-        if (typeof config.content.extract === 'object') {
-          for (let value of Object.values(config.content.extract)) {
-            if (typeof value !== 'function') {
-              return false
-            }
-          }
-        } else if (
-          !(config.content.extract === undefined || typeof config.content.extract === 'function')
-        ) {
-          return false
-        }
-
-        // `config.content.transform` is optional, and can be a Function or a Record<String, Function>
-        if (typeof config.content.transform === 'object') {
-          for (let value of Object.values(config.content.transform)) {
-            if (typeof value !== 'function') {
-              return false
-            }
-          }
-        } else if (
-          !(
-            config.content.transform === undefined || typeof config.content.transform === 'function'
-          )
-        ) {
-          return false
-        }
-      }
-
-      return true
-    }
-
-    return false
-  })()
-
-  if (!valid) {
-    log.warn('purge-deprecation', [
-      'The `purge`/`content` options have changed in Tailwind CSS v3.0.',
-      'Update your configuration file to eliminate this warning.',
-      'https://tailwindcss.com/docs/upgrade-guide#configure-content-sources',
-    ])
-  }
-
-  // Normalize the `safelist`
-  config.safelist = (() => {
-    let { content, purge, safelist } = config
-
-    if (Array.isArray(safelist)) return safelist
-    if (Array.isArray(content?.safelist)) return content.safelist
-    if (Array.isArray(purge?.safelist)) return purge.safelist
-    if (Array.isArray(purge?.options?.safelist)) return purge.options.safelist
-
-    return []
-  })()
-
-  // Normalize prefix option
-  if (typeof config.prefix === 'function') {
-    log.warn('prefix-function', [
-      'As of Tailwind CSS v3.0, `prefix` cannot be a function.',
-      'Update `prefix` in your configuration to be a string to eliminate this warning.',
-      'https://tailwindcss.com/docs/upgrade-guide#prefix-cannot-be-a-function',
-    ])
-    config.prefix = ''
-  } else {
-    config.prefix = config.prefix ?? ''
-  }
-
-  // Normalize the `content`
-  config.content = {
-    files: (() => {
-      let { content, purge } = config
-
-      if (Array.isArray(purge)) return purge
-      if (Array.isArray(purge?.content)) return purge.content
-      if (Array.isArray(content)) return content
-      if (Array.isArray(content?.content)) return content.content
-      if (Array.isArray(content?.files)) return content.files
-
-      return []
-    })(),
-
-    extract: (() => {
-      let extract = (() => {
-        if (config.purge?.extract) return config.purge.extract
-        if (config.content?.extract) return config.content.extract
-
-        if (config.purge?.extract?.DEFAULT) return config.purge.extract.DEFAULT
-        if (config.content?.extract?.DEFAULT) return config.content.extract.DEFAULT
-
-        if (config.purge?.options?.extractors) return config.purge.options.extractors
-        if (config.content?.options?.extractors) return config.content.options.extractors
-
-        return {}
-      })()
-
-      let extractors = {}
-
-      let defaultExtractor = (() => {
-        if (config.purge?.options?.defaultExtractor) {
-          return config.purge.options.defaultExtractor
-        }
-
-        if (config.content?.options?.defaultExtractor) {
-          return config.content.options.defaultExtractor
-        }
-
-        return undefined
-      })()
-
-      if (defaultExtractor !== undefined) {
-        extractors.DEFAULT = defaultExtractor
-      }
-
-      // Functions
-      if (typeof extract === 'function') {
-        extractors.DEFAULT = extract
-      }
-
-      // Arrays
-      else if (Array.isArray(extract)) {
-        for (let { extensions, extractor } of extract ?? []) {
-          for (let extension of extensions) {
-            extractors[extension] = extractor
-          }
-        }
-      }
-
-      // Objects
-      else if (typeof extract === 'object' && extract !== null) {
-        Object.assign(extractors, extract)
-      }
-
-      return extractors
-    })(),
-
-    transform: (() => {
-      let transform = (() => {
-        if (config.purge?.transform) return config.purge.transform
-        if (config.content?.transform) return config.content.transform
-
-        if (config.purge?.transform?.DEFAULT) return config.purge.transform.DEFAULT
-        if (config.content?.transform?.DEFAULT) return config.content.transform.DEFAULT
-
-        return {}
-      })()
-
-      let transformers = {}
-
-      if (typeof transform === 'function') {
-        transformers.DEFAULT = transform
-      }
-
-      if (typeof transform === 'object' && transform !== null) {
-        Object.assign(transformers, transform)
-      }
-
-      return transformers
-    })(),
-  }
-
-  // Validate globs to prevent bogus globs.
-  // E.g.: `./src/*.{html}` is invalid, the `{html}` should just be `html`
-  for (let file of config.content.files) {
-    if (typeof file === 'string' && /{([^,]*?)}/g.test(file)) {
-      log.warn('invalid-glob-braces', [
-        `The glob pattern ${dim(file)} in your Tailwind CSS configuration is invalid.`,
-        `Update it to ${dim(file.replace(/{([^,]*?)}/g, '$1'))} to silence this warning.`,
-        // TODO: Add https://tw.wtf/invalid-glob-braces
-      ])
-      break
-    }
-  }
-
-  if (config.content.files.length === 0) {
-    log.warn('content-problems', [
-      'The `content` option in your Tailwind CSS configuration is missing or empty.',
-      'Configure your content sources or your generated CSS will be missing styles.',
-      'https://tailwindcss.com/docs/content-configuration',
-    ])
-  }
-
-  return config
-}

package/src/util/normalizeScreens.js

@@ -1,45 +0,0 @@
-/**
- * A function that normalizes the various forms that the screens object can be
- * provided in.
- *
- * Input(s):
- *   - ['100px', '200px'] // Raw strings
- *   - { sm: '100px', md: '200px' } // Object with string values
- *   - { sm: { min: '100px' }, md: { max: '100px' } } // Object with object values
- *   - { sm: [{ min: '100px' }, { max: '200px' }] } // Object with object array (multiple values)
- *
- * Output(s):
- *   - [{ name: 'sm', values: [{ min: '100px', max: '200px' }] }] // List of objects, that contains multiple values
- */
-export function normalizeScreens(screens, root = true) {
-  if (Array.isArray(screens)) {
-    return screens.map((screen) => {
-      if (root && Array.isArray(screen)) {
-        throw new Error('The tuple syntax is not supported for `screens`.')
-      }
-
-      if (typeof screen === 'string') {
-        return { name: screen.toString(), values: [{ min: screen, max: undefined }] }
-      }
-
-      let [name, options] = screen
-      name = name.toString()
-
-      if (typeof options === 'string') {
-        return { name, values: [{ min: options, max: undefined }] }
-      }
-
-      if (Array.isArray(options)) {
-        return { name, values: options.map((option) => resolveValue(option)) }
-      }
-
-      return { name, values: [resolveValue(options)] }
-    })
-  }
-
-  return normalizeScreens(Object.entries(screens ?? {}), false)
-}
-
-function resolveValue({ 'min-width': _minWidth, min = _minWidth, max, raw } = {}) {
-  return { min, max, raw }
-}

package/src/util/parseAnimationValue.js

@@ -1,68 +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 if (!seen.has('NAME')) {
-        result.name = part
-        seen.add('NAME')
-      } else {
-        if (!result.unknown) result.unknown = []
-        result.unknown.push(part)
-      }
-    }
-
-    return result
-  })
-}

package/src/util/parseBoxShadowValue.js

@@ -1,119 +0,0 @@
-let KEYWORDS = new Set(['inset', 'inherit', 'initial', 'revert', 'unset'])
-let SPACE = /\ +(?![^(]*\))/g // Similar to the one above, but with spaces instead.
-let LENGTH = /^-?(\d+|\.\d+)(.*?)$/g
-
-let SPECIALS = /[(),]/g
-
-/**
- * This splits a string on top-level commas.
- *
- * Regex doesn't support recursion (at least not the JS-flavored version).
- * So we have to use a tiny state machine to keep track of paren vs comma
- * placement. Before we'd only exclude commas from the inner-most nested
- * set of parens rather than any commas that were not contained in parens
- * at all which is the intended behavior here.
- *
- * Expected behavior:
- * var(--a, 0 0 1px rgb(0, 0, 0)), 0 0 1px rgb(0, 0, 0)
- *       ─┬─             ┬  ┬    ┬
- *        x              x  x    ╰──────── Split because top-level
- *        ╰──────────────┴──┴───────────── Ignored b/c inside >= 1 levels of parens
- *
- * @param {string} input
- */
-function* splitByTopLevelCommas(input) {
-  SPECIALS.lastIndex = -1
-
-  let depth = 0
-  let lastIndex = 0
-  let found = false
-
-  // Find all parens & commas
-  // And only split on commas if they're top-level
-  for (let match of input.matchAll(SPECIALS)) {
-    if (match[0] === '(') depth++
-    if (match[0] === ')') depth--
-    if (match[0] === ',' && depth === 0) {
-      found = true
-
-      yield input.substring(lastIndex, match.index)
-      lastIndex = match.index + match[0].length
-    }
-  }
-
-  // Provide the last segment of the string if available
-  // Otherwise the whole string since no commas were found
-  // This mirrors the behavior of string.split()
-  if (found) {
-    yield input.substring(lastIndex)
-  } else {
-    yield input
-  }
-}
-
-export function parseBoxShadowValue(input) {
-  let shadows = Array.from(splitByTopLevelCommas(input))
-  return shadows.map((shadow) => {
-    let value = shadow.trim()
-    let result = { raw: value }
-    let parts = value.split(SPACE)
-    let seen = new Set()
-
-    for (let part of parts) {
-      // Reset index, since the regex is stateful.
-      LENGTH.lastIndex = 0
-
-      // Keyword
-      if (!seen.has('KEYWORD') && KEYWORDS.has(part)) {
-        result.keyword = part
-        seen.add('KEYWORD')
-      }
-
-      // Length value
-      else if (LENGTH.test(part)) {
-        if (!seen.has('X')) {
-          result.x = part
-          seen.add('X')
-        } else if (!seen.has('Y')) {
-          result.y = part
-          seen.add('Y')
-        } else if (!seen.has('BLUR')) {
-          result.blur = part
-          seen.add('BLUR')
-        } else if (!seen.has('SPREAD')) {
-          result.spread = part
-          seen.add('SPREAD')
-        }
-      }
-
-      // Color or unknown
-      else {
-        if (!result.color) {
-          result.color = part
-        } else {
-          if (!result.unknown) result.unknown = []
-          result.unknown.push(part)
-        }
-      }
-    }
-
-    // Check if valid
-    result.valid = result.x !== undefined && result.y !== undefined
-
-    return result
-  })
-}
-
-export function formatBoxShadowValue(shadows) {
-  return shadows
-    .map((shadow) => {
-      if (!shadow.valid) {
-        return shadow.raw
-      }
-
-      return [shadow.keyword, shadow.x, shadow.y, shadow.blur, shadow.spread, shadow.color]
-        .filter(Boolean)
-        .join(' ')
-    })
-    .join(', ')
-}

package/src/util/parseDependency.js

@@ -1,49 +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) {
-  if (normalizedFileOrGlob.startsWith('!')) {
-    return null
-  }
-
-  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
-  })
-}