tailwindcss 3.4.1 → 4.0.0-alpha.2

package/src/lib/setupTrackingContext.js

@@ -1,169 +0,0 @@
-// @ts-check
-
-import fs from 'fs'
-import LRU from '@alloc/quick-lru'
-
-import hash from '../util/hashConfig'
-import resolveConfig from '../public/resolve-config'
-import resolveConfigPath from '../util/resolveConfigPath'
-import { getContext, getFileModifiedMap } from './setupContextUtils'
-import parseDependency from '../util/parseDependency'
-import { validateConfig } from '../util/validateConfig.js'
-import { parseCandidateFiles, resolvedChangedContent } from './content.js'
-import { loadConfig } from '../lib/load-config'
-import getModuleDependencies from './getModuleDependencies'
-
-let configPathCache = new LRU({ maxSize: 100 })
-
-let candidateFilesCache = new WeakMap()
-
-function getCandidateFiles(context, tailwindConfig) {
-  if (candidateFilesCache.has(context)) {
-    return candidateFilesCache.get(context)
-  }
-
-  let candidateFiles = parseCandidateFiles(context, tailwindConfig)
-
-  return candidateFilesCache.set(context, candidateFiles).get(context)
-}
-
-// Get the config object based on a path
-function getTailwindConfig(configOrPath) {
-  let userConfigPath = resolveConfigPath(configOrPath)
-
-  if (userConfigPath !== null) {
-    let [prevConfig, prevConfigHash, prevDeps, prevModified] =
-      configPathCache.get(userConfigPath) || []
-
-    let newDeps = getModuleDependencies(userConfigPath)
-
-    let modified = false
-    let newModified = new Map()
-    for (let file of newDeps) {
-      let time = fs.statSync(file).mtimeMs
-      newModified.set(file, time)
-      if (!prevModified || !prevModified.has(file) || time > prevModified.get(file)) {
-        modified = true
-      }
-    }
-
-    // It hasn't changed (based on timestamps)
-    if (!modified) {
-      return [prevConfig, userConfigPath, prevConfigHash, prevDeps]
-    }
-
-    // It has changed (based on timestamps), or first run
-    for (let file of newDeps) {
-      delete require.cache[file]
-    }
-    let newConfig = validateConfig(resolveConfig(loadConfig(userConfigPath)))
-    let newHash = hash(newConfig)
-    configPathCache.set(userConfigPath, [newConfig, newHash, newDeps, newModified])
-    return [newConfig, userConfigPath, newHash, newDeps]
-  }
-
-  // It's a plain object, not a path
-  let newConfig = resolveConfig(configOrPath?.config ?? configOrPath ?? {})
-
-  newConfig = validateConfig(newConfig)
-
-  return [newConfig, null, hash(newConfig), []]
-}
-
-// DISABLE_TOUCH = TRUE
-
-// Retrieve an existing context from cache if possible (since contexts are unique per
-// source path), or set up a new one (including setting up watchers and registering
-// plugins) then return it
-export default function setupTrackingContext(configOrPath) {
-  return ({ tailwindDirectives, registerDependency }) => {
-    return (root, result) => {
-      let [tailwindConfig, userConfigPath, tailwindConfigHash, configDependencies] =
-        getTailwindConfig(configOrPath)
-
-      let contextDependencies = new Set(configDependencies)
-
-      // If there are no @tailwind or @apply rules, we don't consider this CSS
-      // file or its dependencies to be dependencies of the context. Can reuse
-      // the context even if they change. We may want to think about `@layer`
-      // being part of this trigger too, but it's tough because it's impossible
-      // for a layer in one file to end up in the actual @tailwind rule in
-      // another file since independent sources are effectively isolated.
-      if (tailwindDirectives.size > 0) {
-        // Add current css file as a context dependencies.
-        contextDependencies.add(result.opts.from)
-
-        // Add all css @import dependencies as context dependencies.
-        for (let message of result.messages) {
-          if (message.type === 'dependency') {
-            contextDependencies.add(message.file)
-          }
-        }
-      }
-
-      let [context, , mTimesToCommit] = getContext(
-        root,
-        result,
-        tailwindConfig,
-        userConfigPath,
-        tailwindConfigHash,
-        contextDependencies
-      )
-
-      let fileModifiedMap = getFileModifiedMap(context)
-
-      let candidateFiles = getCandidateFiles(context, tailwindConfig)
-
-      // If there are no @tailwind or @apply rules, we don't consider this CSS file or it's
-      // dependencies to be dependencies of the context. Can reuse the context even if they change.
-      // We may want to think about `@layer` being part of this trigger too, but it's tough
-      // because it's impossible for a layer in one file to end up in the actual @tailwind rule
-      // in another file since independent sources are effectively isolated.
-      if (tailwindDirectives.size > 0) {
-        // Add template paths as postcss dependencies.
-        for (let contentPath of candidateFiles) {
-          for (let dependency of parseDependency(contentPath)) {
-            registerDependency(dependency)
-          }
-        }
-
-        let [changedContent, contentMTimesToCommit] = resolvedChangedContent(
-          context,
-          candidateFiles,
-          fileModifiedMap
-        )
-
-        for (let content of changedContent) {
-          context.changedContent.push(content)
-        }
-
-        // Add the mtimes of the content files to the commit list
-        // We can overwrite the existing values because unconditionally
-        // This is because:
-        // 1. Most of the files here won't be in the map yet
-        // 2. If they are that means it's a context dependency
-        // and we're reading this after the context. This means
-        // that the mtime we just read is strictly >= the context
-        // mtime. Unless the user / os is doing something weird
-        // in which the mtime would be going backwards. If that
-        // happens there's already going to be problems.
-        for (let [path, mtime] of contentMTimesToCommit.entries()) {
-          mTimesToCommit.set(path, mtime)
-        }
-      }
-
-      for (let file of configDependencies) {
-        registerDependency({ type: 'dependency', file })
-      }
-
-      // "commit" the new modified time for all context deps
-      // We do this here because we want content tracking to
-      // read the "old" mtime even when it's a context dependency.
-      for (let [path, mtime] of mTimesToCommit.entries()) {
-        fileModifiedMap.set(path, mtime)
-      }
-
-      return context
-    }
-  }
-}

package/src/lib/sharedState.js

@@ -1,61 +0,0 @@
-import pkg from '../../package.json'
-
-export const env =
-  typeof process !== 'undefined'
-    ? {
-        NODE_ENV: process.env.NODE_ENV,
-        DEBUG: resolveDebug(process.env.DEBUG),
-        ENGINE: pkg.tailwindcss.engine,
-      }
-    : {
-        NODE_ENV: 'production',
-        DEBUG: false,
-        ENGINE: pkg.tailwindcss.engine,
-      }
-
-export const contextMap = new Map()
-export const configContextMap = new Map()
-export const contextSourcesMap = new Map()
-export const sourceHashMap = new Map()
-export const NOT_ON_DEMAND = new String('*')
-
-export const NONE = Symbol('__NONE__')
-
-export function resolveDebug(debug) {
-  if (debug === undefined) {
-    return false
-  }
-
-  // Environment variables are strings, so convert to boolean
-  if (debug === 'true' || debug === '1') {
-    return true
-  }
-
-  if (debug === 'false' || debug === '0') {
-    return false
-  }
-
-  // Keep the debug convention into account:
-  // DEBUG=* -> This enables all debug modes
-  // DEBUG=projectA,projectB,projectC -> This enables debug for projectA, projectB and projectC
-  // DEBUG=projectA:* -> This enables all debug modes for projectA (if you have sub-types)
-  // DEBUG=projectA,-projectB -> This enables debug for projectA and explicitly disables it for projectB
-
-  if (debug === '*') {
-    return true
-  }
-
-  let debuggers = debug.split(',').map((d) => d.split(':')[0])
-
-  // Ignoring tailwindcss
-  if (debuggers.includes('-tailwindcss')) {
-    return false
-  }
-
-  // Including tailwindcss
-  if (debuggers.includes('tailwindcss')) {
-    return true
-  }
-
-  return false
-}

package/src/lib/substituteScreenAtRules.js

@@ -1,19 +0,0 @@
-import { normalizeScreens } from '../util/normalizeScreens'
-import buildMediaQuery from '../util/buildMediaQuery'
-
-export default function ({ tailwindConfig: { theme } }) {
-  return function (css) {
-    css.walkAtRules('screen', (atRule) => {
-      let screen = atRule.params
-      let screens = normalizeScreens(theme.screens)
-      let screenDefinition = screens.find(({ name }) => name === screen)
-
-      if (!screenDefinition) {
-        throw atRule.error(`No \`${screen}\` screen found.`)
-      }
-
-      atRule.name = 'media'
-      atRule.params = buildMediaQuery(screenDefinition)
-    })
-  }
-}

package/src/oxide/cli/build/deps.ts

@@ -1,91 +0,0 @@
-import packageJson from '../../../../package.json'
-import browserslist from 'browserslist'
-import { Result } from 'postcss'
-
-import {
-  // @ts-ignore
-  lazyPostcss,
-
-  // @ts-ignore
-  lazyPostcssImport,
-
-  // @ts-ignore
-  lazyCssnano,
-
-  // @ts-ignore
-} from '../../../../peers/index'
-
-export function lazyLightningCss() {
-  // TODO: Make this lazy/bundled
-  return require('lightningcss')
-}
-
-let lightningCss
-
-function loadLightningCss() {
-  if (lightningCss) {
-    return lightningCss
-  }
-
-  // Try to load a local version first
-  try {
-    return (lightningCss = require('lightningcss'))
-  } catch {}
-
-  return (lightningCss = lazyLightningCss())
-}
-
-export async function lightningcss(shouldMinify: boolean, result: Result) {
-  let css = loadLightningCss()
-
-  try {
-    let transformed = css.transform({
-      filename: result.opts.from || 'input.css',
-      code: Buffer.from(result.css, 'utf-8'),
-      minify: shouldMinify,
-      sourceMap: !!result.map,
-      inputSourceMap: result.map ? result.map.toString() : undefined,
-      targets: css.browserslistToTargets(browserslist(packageJson.browserslist)),
-      drafts: {
-        nesting: true,
-      },
-    })
-
-    return Object.assign(result, {
-      css: transformed.code.toString('utf8'),
-      map: result.map
-        ? Object.assign(result.map, {
-            toString() {
-              return transformed.map.toString()
-            },
-          })
-        : result.map,
-    })
-  } catch (err) {
-    console.error('Unable to use Lightning CSS. Using raw version instead.')
-    console.error(err)
-
-    return result
-  }
-}
-
-/**
- * @returns {import('postcss')}
- */
-export function loadPostcss() {
-  // Try to load a local `postcss` version first
-  try {
-    return require('postcss')
-  } catch {}
-
-  return lazyPostcss()
-}
-
-export function loadPostcssImport() {
-  // Try to load a local `postcss-import` version first
-  try {
-    return require('postcss-import')
-  } catch {}
-
-  return lazyPostcssImport()
-}

package/src/oxide/cli/build/index.ts

@@ -1,47 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { resolveDefaultConfigPath } from '../../../util/resolveConfigPath'
-import { createProcessor } from './plugin'
-
-export async function build(args) {
-  let input = args['--input']
-  let shouldWatch = args['--watch']
-
-  // TODO: Deprecate this in future versions
-  if (!input && args['_'][1]) {
-    console.error('[deprecation] Running tailwindcss without -i, please provide an input file.')
-    input = args['--input'] = args['_'][1]
-  }
-
-  if (input && input !== '-' && !fs.existsSync((input = path.resolve(input)))) {
-    console.error(`Specified input file ${args['--input']} does not exist.`)
-    process.exit(9)
-  }
-
-  if (args['--config'] && !fs.existsSync((args['--config'] = path.resolve(args['--config'])))) {
-    console.error(`Specified config file ${args['--config']} does not exist.`)
-    process.exit(9)
-  }
-
-  // TODO: Reference the @config path here if exists
-  let configPath = args['--config'] ? args['--config'] : resolveDefaultConfigPath()
-
-  let processor = await createProcessor(args, configPath)
-
-  if (shouldWatch) {
-    // Abort the watcher if stdin is closed to avoid zombie processes
-    // You can disable this behavior with --watch=always
-    if (args['--watch'] !== 'always') {
-      process.stdin.on('end', () => process.exit(0))
-    }
-
-    process.stdin.resume()
-
-    await processor.watch()
-  } else {
-    await processor.build().catch((e) => {
-      console.error(e)
-      process.exit(1)
-    })
-  }
-}