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

package/src/lib/content.js

@@ -1,240 +0,0 @@
-// @ts-check
-
-import fs from 'fs'
-import path from 'path'
-import isGlob from 'is-glob'
-import fastGlob from 'fast-glob'
-import normalizePath from 'normalize-path'
-import { parseGlob } from '../util/parseGlob'
-import { env } from './sharedState'
-import { resolveContentPaths } from '@tailwindcss/oxide'
-
-/** @typedef {import('../../types/config.js').RawFile} RawFile */
-/** @typedef {import('../../types/config.js').FilePath} FilePath */
-
-/*
- * @param {import('tailwindcss').Config} tailwindConfig
- * @param {{skip:string[]}} options
- * @returns {ContentPath[]}
- */
-function resolveContentFiles(tailwindConfig, { skip = [] } = {}) {
-  if (
-    Array.isArray(tailwindConfig.content.files) &&
-    tailwindConfig.content.files.includes('auto')
-  ) {
-    let idx = tailwindConfig.content.files.indexOf('auto')
-    if (idx !== -1) {
-      env.DEBUG && console.time('Calculating resolve content paths')
-      let resolved = resolveContentPaths({ base: process.cwd() })
-      env.DEBUG && console.timeEnd('Calculating resolve content paths')
-
-      tailwindConfig.content.files.splice(idx, 1, ...resolved)
-    }
-  }
-
-  if (skip.length > 0) {
-    tailwindConfig.content.files = tailwindConfig.content.files.filter(
-      (filePath) => !skip.includes(filePath)
-    )
-  }
-
-  return tailwindConfig.content.files
-}
-
-/**
- * @typedef {object} ContentPath
- * @property {string} original
- * @property {string} base
- * @property {string | null} glob
- * @property {boolean} ignore
- * @property {string} pattern
- */
-
-/**
- * Turn a list of content paths (absolute or not; glob or not) into a list of
- * absolute file paths that exist on the filesystem
- *
- * If there are symlinks in the path then multiple paths will be returned
- * one for the symlink and one for the actual file
- *
- * @param {*} context
- * @param {import('tailwindcss').Config} tailwindConfig
- * @returns {ContentPath[]}
- */
-export function parseCandidateFiles(context, tailwindConfig) {
-  let files = resolveContentFiles(tailwindConfig, {
-    skip: [context.userConfigPath],
-  })
-
-  // Normalize the file globs
-  files = files.filter((filePath) => typeof filePath === 'string')
-  files = files.map(normalizePath)
-
-  // Split into included and excluded globs
-  let tasks = fastGlob.generateTasks(files)
-
-  /** @type {ContentPath[]} */
-  let included = []
-
-  /** @type {ContentPath[]} */
-  let excluded = []
-
-  for (const task of tasks) {
-    included.push(...task.positive.map((filePath) => parseFilePath(filePath, false)))
-    excluded.push(...task.negative.map((filePath) => parseFilePath(filePath, true)))
-  }
-
-  let paths = [...included, ...excluded]
-
-  // Resolve paths relative to the config file or cwd
-  paths = resolveRelativePaths(context, paths)
-
-  // Resolve symlinks if possible
-  paths = paths.flatMap(resolvePathSymlinks)
-
-  // Update cached patterns
-  paths = paths.map(resolveGlobPattern)
-
-  return paths
-}
-
-/**
- *
- * @param {string} filePath
- * @param {boolean} ignore
- * @returns {ContentPath}
- */
-function parseFilePath(filePath, ignore) {
-  let contentPath = {
-    original: filePath,
-    base: filePath,
-    ignore,
-    pattern: filePath,
-    glob: null,
-  }
-
-  if (isGlob(filePath)) {
-    Object.assign(contentPath, parseGlob(filePath))
-  }
-
-  return contentPath
-}
-
-/**
- *
- * @param {ContentPath} contentPath
- * @returns {ContentPath}
- */
-function resolveGlobPattern(contentPath) {
-  // This is required for Windows support to properly pick up Glob paths.
-  // Afaik, this technically shouldn't be needed but there's probably
-  // some internal, direct path matching with a normalized path in
-  // a package which can't handle mixed directory separators
-  let base = normalizePath(contentPath.base)
-
-  // If the user's file path contains any special characters (like parens) for instance fast-glob
-  // is like "OOOH SHINY" and treats them as such. So we have to escape the base path to fix this
-  base = fastGlob.escapePath(base)
-
-  contentPath.pattern = contentPath.glob ? `${base}/${contentPath.glob}` : base
-  contentPath.pattern = contentPath.ignore ? `!${contentPath.pattern}` : contentPath.pattern
-
-  return contentPath
-}
-
-/**
- * Resolve each path relative to the config file (when possible) if the experimental flag is enabled
- * Otherwise, resolve relative to the current working directory
- *
- * @param {any} context
- * @param {ContentPath[]} contentPaths
- * @returns {ContentPath[]}
- */
-function resolveRelativePaths(context, contentPaths) {
-  let resolveFrom = []
-
-  // Resolve base paths relative to the config file (when possible) if the experimental flag is enabled
-  if (context.userConfigPath && context.tailwindConfig.content.relative) {
-    resolveFrom = [path.dirname(context.userConfigPath)]
-  }
-
-  return contentPaths.map((contentPath) => {
-    contentPath.base = path.resolve(...resolveFrom, contentPath.base)
-
-    return contentPath
-  })
-}
-
-/**
- * Resolve the symlink for the base directory / file in each path
- * These are added as additional dependencies to watch for changes because
- * some tools (like webpack) will only watch the actual file or directory
- * but not the symlink itself even in projects that use monorepos.
- *
- * @param {ContentPath} contentPath
- * @returns {ContentPath[]}
- */
-function resolvePathSymlinks(contentPath) {
-  let paths = [contentPath]
-
-  try {
-    let resolvedPath = fs.realpathSync(contentPath.base)
-    if (resolvedPath !== contentPath.base) {
-      paths.push({
-        ...contentPath,
-        base: resolvedPath,
-      })
-    }
-  } catch {
-    // TODO: log this?
-  }
-
-  return paths
-}
-
-/**
- * @param {any} context
- * @param {ContentPath[]} candidateFiles
- * @param {Map<string, number>} fileModifiedMap
- * @returns {[{ content: string, extension: string }[], Map<string, number>]}
- */
-export function resolvedChangedContent(context, candidateFiles, fileModifiedMap) {
-  let changedContent = context.tailwindConfig.content.files
-    .filter((item) => typeof item.raw === 'string')
-    .map(({ raw, extension = 'html' }) => ({ content: raw, extension }))
-
-  let [changedFiles, mTimesToCommit] = resolveChangedFiles(candidateFiles, fileModifiedMap)
-
-  for (let changedFile of changedFiles) {
-    let extension = path.extname(changedFile).slice(1)
-    changedContent.push({ file: changedFile, extension })
-  }
-
-  return [changedContent, mTimesToCommit]
-}
-
-/**
- *
- * @param {ContentPath[]} candidateFiles
- * @param {Map<string, number>} fileModifiedMap
- * @returns {[Set<string>, Map<string, number>]}
- */
-function resolveChangedFiles(candidateFiles, fileModifiedMap) {
-  let paths = candidateFiles.map((contentPath) => contentPath.pattern)
-  let mTimesToCommit = new Map()
-
-  let changedFiles = new Set()
-  env.DEBUG && console.time('Finding changed files')
-  let files = fastGlob.sync(paths, { absolute: true })
-  for (let file of files) {
-    let prevModified = fileModifiedMap.get(file) || -Infinity
-    let modified = fs.statSync(file).mtimeMs
-
-    if (modified > prevModified) {
-      changedFiles.add(file)
-      mTimesToCommit.set(file, modified)
-    }
-  }
-  env.DEBUG && console.timeEnd('Finding changed files')
-  return [changedFiles, mTimesToCommit]
-}

package/src/lib/defaultExtractor.js

@@ -1,225 +0,0 @@
-import * as regex from './regex'
-
-export function defaultExtractor(context) {
-  let patterns = Array.from(buildRegExps(context))
-
-  /**
-   * @param {string} content
-   */
-  return (content) => {
-    /** @type {(string|string)[]} */
-    let results = []
-
-    for (let pattern of patterns) {
-      for (let result of content.match(pattern) ?? []) {
-        results.push(clipAtBalancedParens(result))
-      }
-    }
-
-    return results
-  }
-}
-
-function* buildRegExps(context) {
-  let separator = context.tailwindConfig.separator
-  let prefix =
-    context.tailwindConfig.prefix !== ''
-      ? regex.optional(regex.pattern([/-?/, regex.escape(context.tailwindConfig.prefix)]))
-      : ''
-
-  let utility = regex.any([
-    // Arbitrary properties (without square brackets)
-    /\[[^\s:'"`]+:[^\s\[\]]+\]/,
-
-    // Arbitrary properties with balanced square brackets
-    // This is a targeted fix to continue to allow theme()
-    // with square brackets to work in arbitrary properties
-    // while fixing a problem with the regex matching too much
-    /\[[^\s:'"`\]]+:[^\s]+?\[[^\s]+\][^\s]+?\]/,
-
-    // Utilities
-    regex.pattern([
-      // Utility Name / Group Name
-      /-?(?:\w+)/,
-
-      // Normal/Arbitrary values
-      regex.optional(
-        regex.any([
-          regex.pattern([
-            // Arbitrary values
-            regex.any([
-              /-(?:\w+-)*\['[^\s]+'\]/,
-              /-(?:\w+-)*\["[^\s]+"\]/,
-              /-(?:\w+-)*\[`[^\s]+`\]/,
-              /-(?:\w+-)*\[(?:[^\s\[\]]+\[[^\s\[\]]+\])*[^\s:\[\]]+\]/,
-            ]),
-
-            // Not immediately followed by an `{[(`
-            /(?![{([]])/,
-
-            // optionally followed by an opacity modifier
-            /(?:\/[^\s'"`\\><$]*)?/,
-          ]),
-
-          regex.pattern([
-            // Arbitrary values
-            regex.any([
-              /-(?:\w+-)*\['[^\s]+'\]/,
-              /-(?:\w+-)*\["[^\s]+"\]/,
-              /-(?:\w+-)*\[`[^\s]+`\]/,
-              /-(?:\w+-)*\[(?:[^\s\[\]]+\[[^\s\[\]]+\])*[^\s\[\]]+\]/,
-            ]),
-
-            // Not immediately followed by an `{[(`
-            /(?![{([]])/,
-
-            // optionally followed by an opacity modifier
-            /(?:\/[^\s'"`\\$]*)?/,
-          ]),
-
-          // Normal values w/o quotes — may include an opacity modifier
-          /[-\/][^\s'"`\\$={><]*/,
-        ])
-      ),
-    ]),
-  ])
-
-  let variantPatterns = [
-    // Without quotes
-    regex.any([
-      // This is here to provide special support for the `@` variant
-      regex.pattern([/@\[[^\s"'`]+\](\/[^\s"'`]+)?/, separator]),
-
-      // With variant modifier (e.g.: group-[..]/modifier)
-      regex.pattern([/([^\s"'`\[\\]+-)?\[[^\s"'`]+\]\/\w+/, separator]),
-
-      regex.pattern([/([^\s"'`\[\\]+-)?\[[^\s"'`]+\]/, separator]),
-      regex.pattern([/[^\s"'`\[\\]+/, separator]),
-    ]),
-
-    // With quotes allowed
-    regex.any([
-      // With variant modifier (e.g.: group-[..]/modifier)
-      regex.pattern([/([^\s"'`\[\\]+-)?\[[^\s`]+\]\/\w+/, separator]),
-
-      regex.pattern([/([^\s"'`\[\\]+-)?\[[^\s`]+\]/, separator]),
-      regex.pattern([/[^\s`\[\\]+/, separator]),
-    ]),
-  ]
-
-  for (const variantPattern of variantPatterns) {
-    yield regex.pattern([
-      // Variants
-      '((?=((',
-      variantPattern,
-      ')+))\\2)?',
-
-      // Important (optional)
-      /!?/,
-
-      prefix,
-
-      utility,
-    ])
-  }
-
-  // 5. Inner matches
-  yield /[^<>"'`\s.(){}[\]#=%$]*[^<>"'`\s.(){}[\]#=%:$]/g
-}
-
-// We want to capture any "special" characters
-// AND the characters immediately following them (if there is one)
-let SPECIALS = /([\[\]'"`])([^\[\]'"`])?/g
-let ALLOWED_CLASS_CHARACTERS = /[^"'`\s<>\]]+/
-
-/**
- * Clips a string ensuring that parentheses, quotes, etc… are balanced
- * Used for arbitrary values only
- *
- * We will go past the end of the balanced parens until we find a non-class character
- *
- * Depth matching behavior:
- * w-[calc(100%-theme('spacing[some_key][1.5]'))]']
- *   ┬    ┬          ┬┬       ┬        ┬┬   ┬┬┬┬┬┬┬
- *   1    2          3        4        34   3 210 END
- *   ╰────┴──────────┴────────┴────────┴┴───┴─┴┴┴
- *
- * @param {string} input
- */
-function clipAtBalancedParens(input) {
-  // We are care about this for arbitrary values
-  if (!input.includes('-[')) {
-    return input
-  }
-
-  let depth = 0
-  let openStringTypes = []
-
-  // Find all parens, brackets, quotes, etc
-  // Stop when we end at a balanced pair
-  // This is naive and will treat mismatched parens as balanced
-  // This shouldn't be a problem in practice though
-  let matches = input.matchAll(SPECIALS)
-
-  // We can't use lookbehind assertions because we have to support Safari
-  // So, instead, we've emulated it using capture groups and we'll re-work the matches to accommodate
-  matches = Array.from(matches).flatMap((match) => {
-    const [, ...groups] = match
-
-    return groups.map((group, idx) =>
-      Object.assign([], match, {
-        index: match.index + idx,
-        0: group,
-      })
-    )
-  })
-
-  for (let match of matches) {
-    let char = match[0]
-    let inStringType = openStringTypes[openStringTypes.length - 1]
-
-    if (char === inStringType) {
-      openStringTypes.pop()
-    } else if (char === "'" || char === '"' || char === '`') {
-      openStringTypes.push(char)
-    }
-
-    if (inStringType) {
-      continue
-    } else if (char === '[') {
-      depth++
-      continue
-    } else if (char === ']') {
-      depth--
-      continue
-    }
-
-    // We've gone one character past the point where we should stop
-    // This means that there was an extra closing `]`
-    // We'll clip to just before it
-    if (depth < 0) {
-      return input.substring(0, match.index - 1)
-    }
-
-    // We've finished balancing the brackets but there still may be characters that can be included
-    // For example in the class `text-[#336699]/[.35]`
-    // The depth goes to `0` at the closing `]` but goes up again at the `[`
-
-    // If we're at zero and encounter a non-class character then we clip the class there
-    if (depth === 0 && !ALLOWED_CLASS_CHARACTERS.test(char)) {
-      return input.substring(0, match.index)
-    }
-  }
-
-  return input
-}
-
-// Regular utilities
-// {{modifier}:}*{namespace}{-{suffix}}*{/{opacityModifier}}?
-
-// Arbitrary values
-// {{modifier}:}*{namespace}-[{arbitraryValue}]{/{opacityModifier}}?
-// arbitraryValue: no whitespace, balanced quotes unless within quotes, balanced brackets unless within quotes
-
-// Arbitrary properties
-// {{modifier}:}*[{validCssPropertyName}:{arbitraryValue}]

package/src/lib/detectNesting.js

@@ -1,47 +0,0 @@
-function isRoot(node) {
-  return node.type === 'root'
-}
-
-function isAtLayer(node) {
-  return node.type === 'atrule' && node.name === 'layer'
-}
-
-export default function (_context) {
-  return (root, result) => {
-    let found = false
-
-    root.walkAtRules('tailwind', (node) => {
-      if (found) return false
-
-      if (node.parent && !(isRoot(node.parent) || isAtLayer(node.parent))) {
-        found = true
-        node.warn(
-          result,
-          [
-            'Nested @tailwind rules were detected, but are not supported.',
-            "Consider using a prefix to scope Tailwind's classes: https://tailwindcss.com/docs/configuration#prefix",
-            'Alternatively, use the important selector strategy: https://tailwindcss.com/docs/configuration#selector-strategy',
-          ].join('\n')
-        )
-        return false
-      }
-    })
-
-    root.walkRules((rule) => {
-      if (found) return false
-
-      rule.walkRules((nestedRule) => {
-        found = true
-        nestedRule.warn(
-          result,
-          [
-            'Nested CSS was detected, but CSS nesting has not been configured correctly.',
-            'Please enable a CSS nesting plugin *before* Tailwind in your configuration.',
-            'See how here: https://tailwindcss.com/docs/using-with-preprocessors#nesting',
-          ].join('\n')
-        )
-        return false
-      })
-    })
-  }
-}