tailwindcss 0.0.0-insiders.d2bb6f1 → 0.0.0-insiders.d2fdddf

package/src/util/resolveConfig.js

@@ -1,295 +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 resolvePlugins(configs) {
-  let pluginGroups = []
-  let allConfigs = []
-
-  for (let config of configs) {
-    allConfigs.push(config)
-
-    let plugins = []
-
-    for (let plugin of config?.plugins ?? []) {
-      // TODO: If we want to support ESM plugins then a handful of things will have to become async
-      if (typeof plugin === 'string') {
-        // If the plugin is specified as a string then it's just the package name
-        plugin = require(plugin)
-        plugin = plugin.default ?? plugin
-      } else if (Array.isArray(plugin)) {
-        // If the plugin is specified as an array then it's a package name and optional options object
-        // [name] or [name, options]
-        let [pkg, options = undefined] = plugin
-        plugin = require(pkg)
-        plugin = plugin.default ?? plugin
-        plugin = plugin(options)
-      }
-
-      if (plugin.__isOptionsFunction) {
-        plugin = plugin()
-      }
-
-      // We're explicitly skipping registering child plugins
-      // This will change in v4
-      let [, childConfigs] = resolvePlugins([plugin?.config ?? {}])
-
-      plugins.push(plugin)
-      allConfigs.push(...childConfigs)
-    }
-
-    pluginGroups.push(plugins)
-  }
-
-  // Reverse the order of the plugin groups
-  // This matches the old `reduceRight` behavior of the old `resolvePluginLists`
-  // Why? No idea.
-  let plugins = pluginGroups.reverse().flat()
-
-  return [plugins, allConfigs]
-}
-
-function resolveCorePlugins(corePluginConfigs) {
-  const result = [...corePluginConfigs].reduceRight((resolved, corePluginConfig) => {
-    if (isFunction(corePluginConfig)) {
-      return corePluginConfig({ corePlugins: resolved })
-    }
-    return configurePlugins(corePluginConfig, resolved)
-  }, corePluginList)
-
-  return result
-}
-
-export default function resolveConfig(configs) {
-  let [plugins, pluginConfigs] = resolvePlugins(configs)
-
-  let allConfigs = [
-    ...pluginConfigs,
-    {
-      prefix: '',
-      important: false,
-      separator: ':',
-    },
-  ]
-
-  return normalizeConfig(
-    defaults(
-      {
-        theme: resolveFunctionKeys(
-          mergeExtensions(mergeThemes(allConfigs.map((t) => t?.theme ?? {})))
-        ),
-        corePlugins: resolveCorePlugins(allConfigs.map((c) => c.corePlugins)),
-        plugins,
-      },
-      ...allConfigs
-    )
-  )
-}

package/src/util/resolveConfigPath.js

@@ -1,66 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-
-const defaultConfigFiles = [
-  './tailwind.config.js',
-  './tailwind.config.cjs',
-  './tailwind.config.mjs',
-  './tailwind.config.ts',
-]
-
-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')
-  return resolveDefaultConfigPath()
-}
-
-export function resolveDefaultConfigPath() {
-  for (const configFile of defaultConfigFiles) {
-    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/splitAtTopLevelOnly.js

@@ -1,52 +0,0 @@
-/**
- * This splits a string on a top-level character.
- *
- * 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 placement.
- *
- * Expected behavior using commas:
- * 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
- * @param {string} separator
- */
-export function splitAtTopLevelOnly(input, separator) {
-  let stack = []
-  let parts = []
-  let lastPos = 0
-  let isEscaped = false
-
-  for (let idx = 0; idx < input.length; idx++) {
-    let char = input[idx]
-
-    if (stack.length === 0 && char === separator[0] && !isEscaped) {
-      if (separator.length === 1 || input.slice(idx, idx + separator.length) === separator) {
-        parts.push(input.slice(lastPos, idx))
-        lastPos = idx + separator.length
-      }
-    }
-
-    if (isEscaped) {
-      isEscaped = false
-    } else if (char === '\\') {
-      isEscaped = true
-    }
-
-    if (char === '(' || char === '[' || char === '{') {
-      stack.push(char)
-    } else if (
-      (char === ')' && stack[stack.length - 1] === '(') ||
-      (char === ']' && stack[stack.length - 1] === '[') ||
-      (char === '}' && stack[stack.length - 1] === '{')
-    ) {
-      stack.pop()
-    }
-  }
-
-  parts.push(input.slice(lastPos))
-
-  return parts
-}

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,62 +0,0 @@
-import postcss from 'postcss'
-import isPlainObject from './isPlainObject'
-
-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 (themeSection === 'fontFamily') {
-    return (value) => {
-      if (typeof value === 'function') value = value({})
-      let families = Array.isArray(value) && isPlainObject(value[1]) ? value[0] : value
-      return Array.isArray(families) ? families.join(', ') : families
-    }
-  }
-
-  if (
-    [
-      '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, opts = {}) => {
-    if (typeof value === 'function') {
-      value = value(opts)
-    }
-
-    return value
-  }
-}

package/src/util/validateConfig.js

@@ -1,36 +0,0 @@
-import pc from 'picocolors'
-import log from './log'
-
-export function validateConfig(config) {
-  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',
-    ])
-  }
-
-  if (config.content.files.includes('auto')) {
-    log.group('auto-content-experimental', (log) => {
-      log.info([pc.bold('Automatically detecting Tailwind CSS content sources...')])
-      log.warn([
-        'Automatic content detection is experimental, and the behavior may change at any time.',
-      ])
-    })
-  }
-
-  // Warn if the line-clamp plugin is installed
-  try {
-    let plugin = require('@tailwindcss/line-clamp')
-    if (config.plugins.includes(plugin)) {
-      log.warn('line-clamp-in-core', [
-        'As of Tailwind CSS v3.3, the `@tailwindcss/line-clamp` plugin is now included by default.',
-        'Remove it from the `plugins` array in your configuration to eliminate this warning.',
-      ])
-
-      config.plugins = config.plugins.filter((p) => p !== plugin)
-    }
-  } catch {}
-
-  return config
-}

package/src/util/validateFormalSyntax.js

@@ -1,34 +0,0 @@
-import { length, percentage } from './dataTypes'
-import { splitAtTopLevelOnly } from './splitAtTopLevelOnly'
-
-/**
- *
- * https://developer.mozilla.org/en-US/docs/Web/CSS/background-size#formal_syntax
- *
- * background-size =
- *  <bg-size>#
- *
- * <bg-size> =
- *   [ <length-percentage [0,∞]> | auto ]{1,2}  |
- *   cover                                      |
- *   contain
- *
- * <length-percentage> =
- *   <length>      |
- *   <percentage>
- *
- * @param {string} value
- */
-export function backgroundSize(value) {
-  let keywordValues = ['cover', 'contain']
-  // the <length-percentage> type will probably be a css function
-  // so we have to use `splitAtTopLevelOnly`
-  return splitAtTopLevelOnly(value, ',').every((part) => {
-    let sizes = splitAtTopLevelOnly(part, '_').filter(Boolean)
-    if (sizes.length === 1 && keywordValues.includes(sizes[0])) return true
-
-    if (sizes.length !== 1 && sizes.length !== 2) return false
-
-    return sizes.every((size) => length(size) || percentage(size) || size === 'auto')
-  })
-}

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, { loose: true })
-
-  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})` })]
-      })
-    ),
-  }
-}

package/src/value-parser/LICENSE

@@ -1,22 +0,0 @@
-Copyright (c) Bogdan Chadkin <trysound@yandex.ru>
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.

package/src/value-parser/README.md

@@ -1,3 +0,0 @@
-# postcss-value-parser (forked + inlined)
-
-This is a customized version of of [PostCSS Value Parser](https://github.com/TrySound/postcss-value-parser) to fix some bugs around parsing CSS functions.