tailwindcss 0.0.0-insiders.f4635e0 → 0.0.0-insiders.f4a2ccd

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (238) hide show
  1. package/LICENSE +1 -2
  2. package/README.md +15 -7
  3. package/colors.d.ts +3 -0
  4. package/colors.js +2 -304
  5. package/defaultConfig.d.ts +3 -0
  6. package/defaultConfig.js +2 -4
  7. package/defaultTheme.d.ts +4 -0
  8. package/defaultTheme.js +2 -4
  9. package/lib/cli/build/deps.js +54 -0
  10. package/lib/cli/build/index.js +52 -0
  11. package/lib/cli/build/plugin.js +376 -0
  12. package/lib/cli/build/utils.js +78 -0
  13. package/lib/cli/build/watching.js +180 -0
  14. package/lib/cli/help/index.js +71 -0
  15. package/lib/cli/index.js +230 -0
  16. package/lib/cli/init/index.js +61 -0
  17. package/lib/cli-peer-dependencies.js +22 -14
  18. package/lib/cli.js +4 -762
  19. package/lib/corePluginList.js +182 -5
  20. package/lib/corePlugins.js +4109 -2952
  21. package/lib/css/preflight.css +24 -9
  22. package/lib/featureFlags.js +68 -50
  23. package/lib/index.js +5 -30
  24. package/lib/lib/cacheInvalidation.js +90 -0
  25. package/lib/lib/collapseAdjacentRules.js +52 -36
  26. package/lib/lib/collapseDuplicateDeclarations.js +83 -0
  27. package/lib/lib/content.js +177 -0
  28. package/lib/lib/defaultExtractor.js +241 -0
  29. package/lib/lib/detectNesting.js +39 -17
  30. package/lib/lib/evaluateTailwindFunctions.js +203 -161
  31. package/lib/lib/expandApplyAtRules.js +503 -221
  32. package/lib/lib/expandTailwindAtRules.js +255 -243
  33. package/lib/lib/findAtConfigPath.js +44 -0
  34. package/lib/lib/generateRules.js +831 -317
  35. package/lib/lib/getModuleDependencies.js +93 -49
  36. package/lib/lib/load-config.js +36 -0
  37. package/lib/lib/normalizeTailwindDirectives.js +79 -60
  38. package/lib/lib/offsets.js +304 -0
  39. package/lib/lib/partitionApplyAtRules.js +56 -0
  40. package/lib/lib/regex.js +60 -0
  41. package/lib/lib/remap-bitfield.js +87 -0
  42. package/lib/lib/resolveDefaultsAtRules.js +150 -94
  43. package/lib/lib/setupContextUtils.js +1197 -685
  44. package/lib/lib/setupTrackingContext.js +150 -177
  45. package/lib/lib/sharedState.js +70 -21
  46. package/lib/lib/substituteScreenAtRules.js +26 -28
  47. package/lib/oxide/cli/build/deps.js +81 -0
  48. package/lib/oxide/cli/build/index.js +51 -0
  49. package/lib/oxide/cli/build/plugin.js +373 -0
  50. package/lib/oxide/cli/build/utils.js +77 -0
  51. package/lib/oxide/cli/build/watching.js +177 -0
  52. package/lib/oxide/cli/help/index.js +70 -0
  53. package/lib/oxide/cli/index.js +214 -0
  54. package/lib/oxide/cli/init/index.js +50 -0
  55. package/lib/oxide/cli.js +5 -0
  56. package/lib/oxide/postcss-plugin.js +2 -0
  57. package/lib/plugin.js +98 -0
  58. package/{nesting → lib/postcss-plugins/nesting}/README.md +2 -2
  59. package/lib/postcss-plugins/nesting/index.js +19 -0
  60. package/lib/postcss-plugins/nesting/plugin.js +87 -0
  61. package/lib/processTailwindFeatures.js +58 -56
  62. package/lib/public/colors.js +353 -0
  63. package/lib/public/create-plugin.js +15 -0
  64. package/lib/public/default-config.js +16 -0
  65. package/lib/public/default-theme.js +16 -0
  66. package/lib/public/load-config.js +10 -0
  67. package/lib/public/resolve-config.js +22 -0
  68. package/lib/util/applyImportantSelector.js +22 -0
  69. package/lib/util/bigSign.js +7 -6
  70. package/lib/util/buildMediaQuery.js +21 -32
  71. package/lib/util/cloneDeep.js +16 -14
  72. package/lib/util/cloneNodes.js +29 -15
  73. package/lib/util/color.js +104 -66
  74. package/lib/util/configurePlugins.js +17 -15
  75. package/lib/util/createPlugin.js +23 -26
  76. package/lib/util/createUtilityPlugin.js +46 -46
  77. package/lib/util/dataTypes.js +266 -0
  78. package/lib/util/defaults.js +20 -15
  79. package/lib/util/escapeClassName.js +18 -17
  80. package/lib/util/escapeCommas.js +7 -6
  81. package/lib/util/flattenColorPalette.js +13 -12
  82. package/lib/util/formatVariantSelector.js +341 -0
  83. package/lib/util/getAllConfigs.js +44 -18
  84. package/lib/util/hashConfig.js +15 -12
  85. package/lib/util/isKeyframeRule.js +7 -6
  86. package/lib/util/isPlainObject.js +11 -11
  87. package/lib/util/isSyntacticallyValidPropertyValue.js +72 -0
  88. package/lib/util/log.js +52 -33
  89. package/lib/util/nameClass.js +35 -29
  90. package/lib/util/negateValue.js +31 -17
  91. package/lib/util/normalizeConfig.js +294 -0
  92. package/lib/util/normalizeScreens.js +170 -0
  93. package/lib/util/parseAnimationValue.js +85 -54
  94. package/lib/util/parseBoxShadowValue.js +84 -0
  95. package/lib/util/parseDependency.js +41 -70
  96. package/lib/util/parseGlob.js +34 -0
  97. package/lib/util/parseObjectStyles.js +30 -24
  98. package/lib/util/pluginUtils.js +234 -288
  99. package/lib/util/prefixSelector.js +33 -19
  100. package/lib/util/removeAlphaVariables.js +29 -0
  101. package/lib/util/resolveConfig.js +221 -256
  102. package/lib/util/resolveConfigPath.js +55 -48
  103. package/lib/util/responsive.js +18 -14
  104. package/lib/util/splitAtTopLevelOnly.js +49 -0
  105. package/lib/util/tap.js +8 -7
  106. package/lib/util/toColorValue.js +7 -6
  107. package/lib/util/toPath.js +27 -8
  108. package/lib/util/transformThemeValue.js +67 -28
  109. package/lib/util/validateConfig.js +24 -0
  110. package/lib/util/validateFormalSyntax.js +24 -0
  111. package/lib/util/withAlphaVariable.js +67 -57
  112. package/loadConfig.d.ts +4 -0
  113. package/loadConfig.js +2 -0
  114. package/nesting/index.js +2 -12
  115. package/package.json +69 -66
  116. package/peers/index.js +76328 -84169
  117. package/plugin.d.ts +11 -0
  118. package/plugin.js +1 -2
  119. package/resolveConfig.d.ts +12 -0
  120. package/resolveConfig.js +2 -7
  121. package/scripts/create-plugin-list.js +2 -2
  122. package/scripts/generate-types.js +105 -0
  123. package/scripts/release-channel.js +18 -0
  124. package/scripts/release-notes.js +21 -0
  125. package/scripts/swap-engines.js +40 -0
  126. package/scripts/type-utils.js +27 -0
  127. package/src/cli/build/deps.js +56 -0
  128. package/src/cli/build/index.js +49 -0
  129. package/src/cli/build/plugin.js +444 -0
  130. package/src/cli/build/utils.js +76 -0
  131. package/src/cli/build/watching.js +229 -0
  132. package/src/cli/help/index.js +70 -0
  133. package/src/cli/index.js +216 -0
  134. package/src/cli/init/index.js +79 -0
  135. package/src/cli-peer-dependencies.js +7 -1
  136. package/src/cli.js +4 -756
  137. package/src/corePluginList.js +1 -1
  138. package/src/corePlugins.js +2526 -1956
  139. package/src/css/preflight.css +24 -9
  140. package/src/featureFlags.js +33 -10
  141. package/src/index.js +4 -33
  142. package/src/lib/cacheInvalidation.js +52 -0
  143. package/src/lib/collapseAdjacentRules.js +21 -2
  144. package/src/lib/collapseDuplicateDeclarations.js +93 -0
  145. package/src/lib/content.js +208 -0
  146. package/src/lib/defaultExtractor.js +217 -0
  147. package/src/lib/detectNesting.js +30 -3
  148. package/src/lib/evaluateTailwindFunctions.js +84 -10
  149. package/src/lib/expandApplyAtRules.js +509 -153
  150. package/src/lib/expandTailwindAtRules.js +125 -104
  151. package/src/lib/findAtConfigPath.js +48 -0
  152. package/src/lib/generateRules.js +678 -70
  153. package/src/lib/getModuleDependencies.js +70 -30
  154. package/src/lib/load-config.ts +27 -0
  155. package/src/lib/normalizeTailwindDirectives.js +10 -3
  156. package/src/lib/offsets.js +373 -0
  157. package/src/lib/partitionApplyAtRules.js +52 -0
  158. package/src/lib/regex.js +74 -0
  159. package/src/lib/remap-bitfield.js +82 -0
  160. package/src/lib/resolveDefaultsAtRules.js +105 -47
  161. package/src/lib/setupContextUtils.js +848 -247
  162. package/src/lib/setupTrackingContext.js +53 -64
  163. package/src/lib/sharedState.js +60 -6
  164. package/src/lib/substituteScreenAtRules.js +6 -3
  165. package/src/oxide/cli/build/deps.ts +91 -0
  166. package/src/oxide/cli/build/index.ts +47 -0
  167. package/src/oxide/cli/build/plugin.ts +442 -0
  168. package/src/oxide/cli/build/utils.ts +74 -0
  169. package/src/oxide/cli/build/watching.ts +225 -0
  170. package/src/oxide/cli/help/index.ts +69 -0
  171. package/src/oxide/cli/index.ts +204 -0
  172. package/src/oxide/cli/init/index.ts +59 -0
  173. package/src/oxide/cli.ts +1 -0
  174. package/src/oxide/postcss-plugin.ts +1 -0
  175. package/src/plugin.js +107 -0
  176. package/src/postcss-plugins/nesting/README.md +42 -0
  177. package/src/postcss-plugins/nesting/index.js +13 -0
  178. package/src/postcss-plugins/nesting/plugin.js +80 -0
  179. package/src/processTailwindFeatures.js +18 -3
  180. package/src/public/colors.js +322 -0
  181. package/src/public/create-plugin.js +2 -0
  182. package/src/public/default-config.js +4 -0
  183. package/src/public/default-theme.js +4 -0
  184. package/src/public/load-config.js +2 -0
  185. package/src/public/resolve-config.js +7 -0
  186. package/src/util/applyImportantSelector.js +19 -0
  187. package/src/util/buildMediaQuery.js +14 -16
  188. package/src/util/cloneNodes.js +19 -2
  189. package/src/util/color.js +43 -11
  190. package/src/util/createUtilityPlugin.js +2 -11
  191. package/src/util/dataTypes.js +281 -0
  192. package/src/util/defaults.js +6 -0
  193. package/src/util/formatVariantSelector.js +412 -0
  194. package/src/util/getAllConfigs.js +21 -2
  195. package/src/util/isSyntacticallyValidPropertyValue.js +61 -0
  196. package/src/util/log.js +23 -22
  197. package/src/util/nameClass.js +6 -2
  198. package/src/util/negateValue.js +15 -5
  199. package/src/util/normalizeConfig.js +318 -0
  200. package/src/util/normalizeScreens.js +140 -0
  201. package/src/util/parseAnimationValue.js +7 -1
  202. package/src/util/parseBoxShadowValue.js +72 -0
  203. package/src/util/parseDependency.js +37 -38
  204. package/src/util/parseGlob.js +24 -0
  205. package/src/util/pluginUtils.js +219 -219
  206. package/src/util/prefixSelector.js +30 -13
  207. package/src/util/removeAlphaVariables.js +24 -0
  208. package/src/util/resolveConfig.js +86 -91
  209. package/src/util/resolveConfigPath.js +12 -1
  210. package/src/util/splitAtTopLevelOnly.js +52 -0
  211. package/src/util/toPath.js +23 -1
  212. package/src/util/transformThemeValue.js +33 -8
  213. package/src/util/validateConfig.js +13 -0
  214. package/src/util/validateFormalSyntax.js +34 -0
  215. package/src/util/withAlphaVariable.js +14 -9
  216. package/stubs/.gitignore +1 -0
  217. package/stubs/.prettierrc.json +6 -0
  218. package/stubs/{defaultConfig.stub.js → config.full.js} +332 -249
  219. package/stubs/{simpleConfig.stub.js → config.simple.js} +0 -1
  220. package/stubs/postcss.config.js +6 -0
  221. package/stubs/tailwind.config.cjs +2 -0
  222. package/stubs/tailwind.config.js +2 -0
  223. package/stubs/tailwind.config.ts +3 -0
  224. package/types/config.d.ts +373 -0
  225. package/types/generated/.gitkeep +0 -0
  226. package/types/generated/colors.d.ts +298 -0
  227. package/types/generated/corePluginList.d.ts +1 -0
  228. package/types/generated/default-theme.d.ts +347 -0
  229. package/types/index.d.ts +7 -0
  230. package/CHANGELOG.md +0 -1742
  231. package/lib/constants.js +0 -37
  232. package/lib/lib/setupWatchingContext.js +0 -331
  233. package/nesting/plugin.js +0 -41
  234. package/scripts/install-integrations.js +0 -27
  235. package/scripts/rebuildFixtures.js +0 -68
  236. package/src/constants.js +0 -17
  237. package/src/lib/setupWatchingContext.js +0 -307
  238. /package/stubs/{defaultPostCssConfig.stub.js → postcss.config.cjs} +0 -0
@@ -11,12 +11,94 @@ import isPlainObject from '../util/isPlainObject'
11
11
  import escapeClassName from '../util/escapeClassName'
12
12
  import nameClass, { formatClass } from '../util/nameClass'
13
13
  import { coerceValue } from '../util/pluginUtils'
14
- import bigSign from '../util/bigSign'
15
- import * as corePlugins from '../corePlugins'
14
+ import { variantPlugins, corePlugins } from '../corePlugins'
16
15
  import * as sharedState from './sharedState'
17
16
  import { env } from './sharedState'
18
17
  import { toPath } from '../util/toPath'
19
18
  import log from '../util/log'
19
+ import negateValue from '../util/negateValue'
20
+ import isSyntacticallyValidPropertyValue from '../util/isSyntacticallyValidPropertyValue'
21
+ import { generateRules, getClassNameFromSelector } from './generateRules'
22
+ import { hasContentChanged } from './cacheInvalidation.js'
23
+ import { Offsets } from './offsets.js'
24
+ import { flagEnabled } from '../featureFlags.js'
25
+ import { finalizeSelector, formatVariantSelector } from '../util/formatVariantSelector'
26
+
27
+ const VARIANT_TYPES = {
28
+ AddVariant: Symbol.for('ADD_VARIANT'),
29
+ MatchVariant: Symbol.for('MATCH_VARIANT'),
30
+ }
31
+
32
+ const VARIANT_INFO = {
33
+ Base: 1 << 0,
34
+ Dynamic: 1 << 1,
35
+ }
36
+
37
+ function prefix(context, selector) {
38
+ let prefix = context.tailwindConfig.prefix
39
+ return typeof prefix === 'function' ? prefix(selector) : prefix + selector
40
+ }
41
+
42
+ function normalizeOptionTypes({ type = 'any', ...options }) {
43
+ let types = [].concat(type)
44
+
45
+ return {
46
+ ...options,
47
+ types: types.map((type) => {
48
+ if (Array.isArray(type)) {
49
+ return { type: type[0], ...type[1] }
50
+ }
51
+ return { type, preferOnConflict: false }
52
+ }),
53
+ }
54
+ }
55
+
56
+ function parseVariantFormatString(input) {
57
+ /** @type {string[]} */
58
+ let parts = []
59
+
60
+ // When parsing whitespace around special characters are insignificant
61
+ // However, _inside_ of a variant they could be
62
+ // Because the selector could look like this
63
+ // @media { &[data-name="foo bar"] }
64
+ // This is why we do not skip whitespace
65
+
66
+ let current = ''
67
+ let depth = 0
68
+
69
+ for (let idx = 0; idx < input.length; idx++) {
70
+ let char = input[idx]
71
+
72
+ if (char === '\\') {
73
+ // Escaped characters are not special
74
+ current += '\\' + input[++idx]
75
+ } else if (char === '{') {
76
+ // Nested rule: start
77
+ ++depth
78
+ parts.push(current.trim())
79
+ current = ''
80
+ } else if (char === '}') {
81
+ // Nested rule: end
82
+ if (--depth < 0) {
83
+ throw new Error(`Your { and } are unbalanced.`)
84
+ }
85
+
86
+ parts.push(current.trim())
87
+ current = ''
88
+ } else {
89
+ // Normal character
90
+ current += char
91
+ }
92
+ }
93
+
94
+ if (current.length > 0) {
95
+ parts.push(current.trim())
96
+ }
97
+
98
+ parts = parts.filter((part) => part !== '')
99
+
100
+ return parts
101
+ }
20
102
 
21
103
  function insertInto(list, value, { before = [] } = {}) {
22
104
  before = [].concat(before)
@@ -47,39 +129,82 @@ function parseStyles(styles) {
47
129
  })
48
130
  }
49
131
 
50
- function getClasses(selector) {
132
+ function getClasses(selector, mutate) {
51
133
  let parser = selectorParser((selectors) => {
52
134
  let allClasses = []
135
+
136
+ if (mutate) {
137
+ mutate(selectors)
138
+ }
139
+
53
140
  selectors.walkClasses((classNode) => {
54
141
  allClasses.push(classNode.value)
55
142
  })
143
+
56
144
  return allClasses
57
145
  })
58
146
  return parser.transformSync(selector)
59
147
  }
60
148
 
61
- function extractCandidates(node) {
62
- let classes = node.type === 'rule' ? getClasses(node.selector) : []
149
+ function extractCandidates(node, state = { containsNonOnDemandable: false }, depth = 0) {
150
+ let classes = []
151
+
152
+ // Handle normal rules
153
+ if (node.type === 'rule') {
154
+ // Ignore everything inside a :not(...). This allows you to write code like
155
+ // `div:not(.foo)`. If `.foo` is never found in your code, then we used to
156
+ // not generated it. But now we will ignore everything inside a `:not`, so
157
+ // that it still gets generated.
158
+ function ignoreNot(selectors) {
159
+ selectors.walkPseudos((pseudo) => {
160
+ if (pseudo.value === ':not') {
161
+ pseudo.remove()
162
+ }
163
+ })
164
+ }
165
+
166
+ for (let selector of node.selectors) {
167
+ let classCandidates = getClasses(selector, ignoreNot)
168
+ // At least one of the selectors contains non-"on-demandable" candidates.
169
+ if (classCandidates.length === 0) {
170
+ state.containsNonOnDemandable = true
171
+ }
172
+
173
+ for (let classCandidate of classCandidates) {
174
+ classes.push(classCandidate)
175
+ }
176
+ }
177
+ }
63
178
 
64
- if (node.type === 'atrule') {
179
+ // Handle at-rules (which contains nested rules)
180
+ else if (node.type === 'atrule') {
65
181
  node.walkRules((rule) => {
66
- classes = [...classes, ...getClasses(rule.selector)]
182
+ for (let classCandidate of rule.selectors.flatMap((selector) => getClasses(selector))) {
183
+ classes.push(classCandidate)
184
+ }
67
185
  })
68
186
  }
69
187
 
188
+ if (depth === 0) {
189
+ return [state.containsNonOnDemandable || classes.length === 0, classes]
190
+ }
191
+
70
192
  return classes
71
193
  }
72
194
 
73
195
  function withIdentifiers(styles) {
74
196
  return parseStyles(styles).flatMap((node) => {
75
197
  let nodeMap = new Map()
76
- let candidates = extractCandidates(node)
198
+ let [containsNonOnDemandableSelectors, candidates] = extractCandidates(node)
77
199
 
78
- // If this isn't "on-demandable", assign it a universal candidate.
79
- if (candidates.length === 0) {
80
- return [['*', node]]
200
+ // If this isn't "on-demandable", assign it a universal candidate to always include it.
201
+ if (containsNonOnDemandableSelectors) {
202
+ candidates.unshift(sharedState.NOT_ON_DEMAND)
81
203
  }
82
204
 
205
+ // However, it could be that it also contains "on-demandable" candidates.
206
+ // E.g.: `span, .foo {}`, in that case it should still be possible to use
207
+ // `@apply foo` for example.
83
208
  return candidates.map((c) => {
84
209
  if (!nodeMap.has(node)) {
85
210
  nodeMap.set(node, node)
@@ -89,64 +214,41 @@ function withIdentifiers(styles) {
89
214
  })
90
215
  }
91
216
 
92
- let matchingBrackets = new Map([
93
- ['{', '}'],
94
- ['[', ']'],
95
- ['(', ')'],
96
- ])
97
- let inverseMatchingBrackets = new Map(
98
- Array.from(matchingBrackets.entries()).map(([k, v]) => [v, k])
99
- )
100
-
101
- let quotes = new Set(['"', "'", '`'])
102
-
103
- // Arbitrary values must contain balanced brackets (), [] and {}. Escaped
104
- // values don't count, and brackets inside quotes also don't count.
105
- //
106
- // E.g.: w-[this-is]w-[weird-and-invalid]
107
- // E.g.: w-[this-is\\]w-\\[weird-but-valid]
108
- // E.g.: content-['this-is-also-valid]-weirdly-enough']
109
- function isValidArbitraryValue(value) {
110
- let stack = []
111
- let inQuotes = false
112
-
113
- for (let i = 0; i < value.length; i++) {
114
- let char = value[i]
115
-
116
- // Non-escaped quotes allow us to "allow" anything in between
117
- if (quotes.has(char) && value[i - 1] !== '\\') {
118
- inQuotes = !inQuotes
119
- }
120
-
121
- if (inQuotes) continue
122
- if (value[i - 1] === '\\') continue // Escaped
217
+ export function isValidVariantFormatString(format) {
218
+ return format.startsWith('@') || format.includes('&')
219
+ }
123
220
 
124
- if (matchingBrackets.has(char)) {
125
- stack.push(char)
126
- } else if (inverseMatchingBrackets.has(char)) {
127
- let inverse = inverseMatchingBrackets.get(char)
221
+ export function parseVariant(variant) {
222
+ variant = variant
223
+ .replace(/\n+/g, '')
224
+ .replace(/\s{1,}/g, ' ')
225
+ .trim()
128
226
 
129
- // Nothing to pop from, therefore it is unbalanced
130
- if (stack.length <= 0) {
131
- return false
227
+ let fns = parseVariantFormatString(variant)
228
+ .map((str) => {
229
+ if (!str.startsWith('@')) {
230
+ return ({ format }) => format(str)
132
231
  }
133
232
 
134
- // Popped value must match the inverse value, otherwise it is unbalanced
135
- if (stack.pop() !== inverse) {
136
- return false
137
- }
138
- }
139
- }
233
+ let [, name, params] = /@(.*?)( .+|[({].*)/g.exec(str)
234
+ return ({ wrap }) => wrap(postcss.atRule({ name, params: params.trim() }))
235
+ })
236
+ .reverse()
140
237
 
141
- // If there is still something on the stack, it is also unbalanced
142
- if (stack.length > 0) {
143
- return false
238
+ return (api) => {
239
+ for (let fn of fns) {
240
+ fn(api)
241
+ }
144
242
  }
145
-
146
- // All good, totally balanced!
147
- return true
148
243
  }
149
244
 
245
+ /**
246
+ *
247
+ * @param {any} tailwindConfig
248
+ * @param {any} context
249
+ * @param {object} param2
250
+ * @param {Offsets} param2.offsets
251
+ */
150
252
  function buildPluginApi(tailwindConfig, context, { variantList, variantMap, offsets, classList }) {
151
253
  function getConfigValue(path, defaultValue) {
152
254
  return path ? dlv(tailwindConfig, path, defaultValue) : tailwindConfig
@@ -157,37 +259,30 @@ function buildPluginApi(tailwindConfig, context, { variantList, variantMap, offs
157
259
  }
158
260
 
159
261
  function prefixIdentifier(identifier, options) {
160
- if (identifier === '*') {
161
- return '*'
262
+ if (identifier === sharedState.NOT_ON_DEMAND) {
263
+ return sharedState.NOT_ON_DEMAND
162
264
  }
163
265
 
164
266
  if (!options.respectPrefix) {
165
267
  return identifier
166
268
  }
167
269
 
168
- if (typeof context.tailwindConfig.prefix === 'function') {
169
- return prefixSelector(context.tailwindConfig.prefix, `.${identifier}`).substr(1)
170
- }
171
-
172
270
  return context.tailwindConfig.prefix + identifier
173
271
  }
174
272
 
175
- return {
176
- addVariant(variantName, variantFunctions, options = {}) {
177
- variantFunctions = [].concat(variantFunctions)
273
+ function resolveThemeValue(path, defaultValue, opts = {}) {
274
+ let parts = toPath(path)
275
+ let value = getConfigValue(['theme', ...parts], defaultValue)
276
+ return transformThemeValue(parts[0])(value, opts)
277
+ }
178
278
 
179
- insertInto(variantList, variantName, options)
180
- variantMap.set(variantName, variantFunctions)
181
- },
279
+ let variantIdentifier = 0
280
+ let api = {
182
281
  postcss,
183
282
  prefix: applyConfiguredPrefix,
184
283
  e: escapeClassName,
185
284
  config: getConfigValue,
186
- theme(path, defaultValue) {
187
- const [pathRoot, ...subPaths] = toPath(path)
188
- const value = getConfigValue(['theme', pathRoot, ...subPaths], defaultValue)
189
- return transformThemeValue(pathRoot)(value)
190
- },
285
+ theme: resolveThemeValue,
191
286
  corePlugins: (path) => {
192
287
  if (Array.isArray(tailwindConfig.corePlugins)) {
193
288
  return tailwindConfig.corePlugins.includes(path)
@@ -199,21 +294,31 @@ function buildPluginApi(tailwindConfig, context, { variantList, variantMap, offs
199
294
  // Preserved for backwards compatibility but not used in v3.0+
200
295
  return []
201
296
  },
202
- addUserCss(userCss) {
203
- for (let [identifier, rule] of withIdentifiers(userCss)) {
204
- let offset = offsets.user++
297
+ addBase(base) {
298
+ for (let [identifier, rule] of withIdentifiers(base)) {
299
+ let prefixedIdentifier = prefixIdentifier(identifier, {})
300
+ let offset = offsets.create('base')
205
301
 
206
- if (!context.candidateRuleMap.has(identifier)) {
207
- context.candidateRuleMap.set(identifier, [])
302
+ if (!context.candidateRuleMap.has(prefixedIdentifier)) {
303
+ context.candidateRuleMap.set(prefixedIdentifier, [])
208
304
  }
209
305
 
210
- context.candidateRuleMap.get(identifier).push([{ sort: offset, layer: 'user' }, rule])
306
+ context.candidateRuleMap
307
+ .get(prefixedIdentifier)
308
+ .push([{ sort: offset, layer: 'base' }, rule])
211
309
  }
212
310
  },
213
- addBase(base) {
214
- for (let [identifier, rule] of withIdentifiers(base)) {
311
+ /**
312
+ * @param {string} group
313
+ * @param {Record<string, string | string[]>} declarations
314
+ */
315
+ addDefaults(group, declarations) {
316
+ const groups = {
317
+ [`@defaults ${group}`]: declarations,
318
+ }
319
+
320
+ for (let [identifier, rule] of withIdentifiers(groups)) {
215
321
  let prefixedIdentifier = prefixIdentifier(identifier, {})
216
- let offset = offsets.base++
217
322
 
218
323
  if (!context.candidateRuleMap.has(prefixedIdentifier)) {
219
324
  context.candidateRuleMap.set(prefixedIdentifier, [])
@@ -221,26 +326,20 @@ function buildPluginApi(tailwindConfig, context, { variantList, variantMap, offs
221
326
 
222
327
  context.candidateRuleMap
223
328
  .get(prefixedIdentifier)
224
- .push([{ sort: offset, layer: 'base' }, rule])
329
+ .push([{ sort: offsets.create('defaults'), layer: 'defaults' }, rule])
225
330
  }
226
331
  },
227
332
  addComponents(components, options) {
228
333
  let defaultOptions = {
229
- variants: [],
334
+ preserveSource: false,
230
335
  respectPrefix: true,
231
336
  respectImportant: false,
232
- respectVariants: true,
233
337
  }
234
338
 
235
- options = Object.assign(
236
- {},
237
- defaultOptions,
238
- Array.isArray(options) ? { variants: options } : options
239
- )
339
+ options = Object.assign({}, defaultOptions, Array.isArray(options) ? {} : options)
240
340
 
241
341
  for (let [identifier, rule] of withIdentifiers(components)) {
242
342
  let prefixedIdentifier = prefixIdentifier(identifier, options)
243
- let offset = offsets.components++
244
343
 
245
344
  classList.add(prefixedIdentifier)
246
345
 
@@ -250,26 +349,20 @@ function buildPluginApi(tailwindConfig, context, { variantList, variantMap, offs
250
349
 
251
350
  context.candidateRuleMap
252
351
  .get(prefixedIdentifier)
253
- .push([{ sort: offset, layer: 'components', options }, rule])
352
+ .push([{ sort: offsets.create('components'), layer: 'components', options }, rule])
254
353
  }
255
354
  },
256
355
  addUtilities(utilities, options) {
257
356
  let defaultOptions = {
258
- variants: [],
357
+ preserveSource: false,
259
358
  respectPrefix: true,
260
359
  respectImportant: true,
261
- respectVariants: true,
262
360
  }
263
361
 
264
- options = Object.assign(
265
- {},
266
- defaultOptions,
267
- Array.isArray(options) ? { variants: options } : options
268
- )
362
+ options = Object.assign({}, defaultOptions, Array.isArray(options) ? {} : options)
269
363
 
270
364
  for (let [identifier, rule] of withIdentifiers(utilities)) {
271
365
  let prefixedIdentifier = prefixIdentifier(identifier, options)
272
- let offset = offsets.utilities++
273
366
 
274
367
  classList.add(prefixedIdentifier)
275
368
 
@@ -279,20 +372,19 @@ function buildPluginApi(tailwindConfig, context, { variantList, variantMap, offs
279
372
 
280
373
  context.candidateRuleMap
281
374
  .get(prefixedIdentifier)
282
- .push([{ sort: offset, layer: 'utilities', options }, rule])
375
+ .push([{ sort: offsets.create('utilities'), layer: 'utilities', options }, rule])
283
376
  }
284
377
  },
285
378
  matchUtilities: function (utilities, options) {
286
379
  let defaultOptions = {
287
- variants: [],
288
380
  respectPrefix: true,
289
381
  respectImportant: true,
290
- respectVariants: true,
382
+ modifiers: false,
291
383
  }
292
384
 
293
- options = { ...defaultOptions, ...options }
385
+ options = normalizeOptionTypes({ ...defaultOptions, ...options })
294
386
 
295
- let offset = offsets.utilities++
387
+ let offset = offsets.create('utilities')
296
388
 
297
389
  for (let identifier in utilities) {
298
390
  let prefixedIdentifier = prefixIdentifier(identifier, options)
@@ -300,34 +392,58 @@ function buildPluginApi(tailwindConfig, context, { variantList, variantMap, offs
300
392
 
301
393
  classList.add([prefixedIdentifier, options])
302
394
 
303
- function wrapped(modifier) {
304
- let { type = 'any' } = options
305
- type = [].concat(type)
306
- let [value, coercedType] = coerceValue(type, modifier, options.values, tailwindConfig)
395
+ function wrapped(modifier, { isOnlyPlugin }) {
396
+ let [value, coercedType, utilityModifier] = coerceValue(
397
+ options.types,
398
+ modifier,
399
+ options,
400
+ tailwindConfig
401
+ )
307
402
 
308
- if (!type.includes(coercedType) || value === undefined) {
403
+ if (value === undefined) {
309
404
  return []
310
405
  }
311
406
 
312
- if (!isValidArbitraryValue(value)) {
407
+ if (!options.types.some(({ type }) => type === coercedType)) {
408
+ if (isOnlyPlugin) {
409
+ log.warn([
410
+ `Unnecessary typehint \`${coercedType}\` in \`${identifier}-${modifier}\`.`,
411
+ `You can safely update it to \`${identifier}-${modifier.replace(
412
+ coercedType + ':',
413
+ ''
414
+ )}\`.`,
415
+ ])
416
+ } else {
417
+ return []
418
+ }
419
+ }
420
+
421
+ if (!isSyntacticallyValidPropertyValue(value)) {
313
422
  return []
314
423
  }
315
424
 
316
- let includedRules = []
425
+ let extras = {
426
+ get modifier() {
427
+ if (!options.modifiers) {
428
+ log.warn(`modifier-used-without-options-for-${identifier}`, [
429
+ 'Your plugin must set `modifiers: true` in its options to support modifiers.',
430
+ ])
431
+ }
432
+
433
+ return utilityModifier
434
+ },
435
+ }
436
+
437
+ let modifiersEnabled = flagEnabled(tailwindConfig, 'generalizedModifiers')
438
+
317
439
  let ruleSets = []
318
- .concat(
319
- rule(value, {
320
- includeRules(rules) {
321
- includedRules.push(...rules)
322
- },
323
- })
324
- )
440
+ .concat(modifiersEnabled ? rule(value, extras) : rule(value))
325
441
  .filter(Boolean)
326
442
  .map((declaration) => ({
327
443
  [nameClass(identifier, modifier)]: declaration,
328
444
  }))
329
445
 
330
- return [...includedRules, ...ruleSets]
446
+ return ruleSets
331
447
  }
332
448
 
333
449
  let withOffsets = [{ sort: offset, layer: 'utilities', options }, wrapped]
@@ -339,7 +455,189 @@ function buildPluginApi(tailwindConfig, context, { variantList, variantMap, offs
339
455
  context.candidateRuleMap.get(prefixedIdentifier).push(withOffsets)
340
456
  }
341
457
  },
458
+ matchComponents: function (components, options) {
459
+ let defaultOptions = {
460
+ respectPrefix: true,
461
+ respectImportant: false,
462
+ modifiers: false,
463
+ }
464
+
465
+ options = normalizeOptionTypes({ ...defaultOptions, ...options })
466
+
467
+ let offset = offsets.create('components')
468
+
469
+ for (let identifier in components) {
470
+ let prefixedIdentifier = prefixIdentifier(identifier, options)
471
+ let rule = components[identifier]
472
+
473
+ classList.add([prefixedIdentifier, options])
474
+
475
+ function wrapped(modifier, { isOnlyPlugin }) {
476
+ let [value, coercedType, utilityModifier] = coerceValue(
477
+ options.types,
478
+ modifier,
479
+ options,
480
+ tailwindConfig
481
+ )
482
+
483
+ if (value === undefined) {
484
+ return []
485
+ }
486
+
487
+ if (!options.types.some(({ type }) => type === coercedType)) {
488
+ if (isOnlyPlugin) {
489
+ log.warn([
490
+ `Unnecessary typehint \`${coercedType}\` in \`${identifier}-${modifier}\`.`,
491
+ `You can safely update it to \`${identifier}-${modifier.replace(
492
+ coercedType + ':',
493
+ ''
494
+ )}\`.`,
495
+ ])
496
+ } else {
497
+ return []
498
+ }
499
+ }
500
+
501
+ if (!isSyntacticallyValidPropertyValue(value)) {
502
+ return []
503
+ }
504
+
505
+ let extras = {
506
+ get modifier() {
507
+ if (!options.modifiers) {
508
+ log.warn(`modifier-used-without-options-for-${identifier}`, [
509
+ 'Your plugin must set `modifiers: true` in its options to support modifiers.',
510
+ ])
511
+ }
512
+
513
+ return utilityModifier
514
+ },
515
+ }
516
+
517
+ let modifiersEnabled = flagEnabled(tailwindConfig, 'generalizedModifiers')
518
+
519
+ let ruleSets = []
520
+ .concat(modifiersEnabled ? rule(value, extras) : rule(value))
521
+ .filter(Boolean)
522
+ .map((declaration) => ({
523
+ [nameClass(identifier, modifier)]: declaration,
524
+ }))
525
+
526
+ return ruleSets
527
+ }
528
+
529
+ let withOffsets = [{ sort: offset, layer: 'components', options }, wrapped]
530
+
531
+ if (!context.candidateRuleMap.has(prefixedIdentifier)) {
532
+ context.candidateRuleMap.set(prefixedIdentifier, [])
533
+ }
534
+
535
+ context.candidateRuleMap.get(prefixedIdentifier).push(withOffsets)
536
+ }
537
+ },
538
+ addVariant(variantName, variantFunctions, options = {}) {
539
+ variantFunctions = [].concat(variantFunctions).map((variantFunction) => {
540
+ if (typeof variantFunction !== 'string') {
541
+ // Safelist public API functions
542
+ return (api = {}) => {
543
+ let { args, modifySelectors, container, separator, wrap, format } = api
544
+ let result = variantFunction(
545
+ Object.assign(
546
+ { modifySelectors, container, separator },
547
+ options.type === VARIANT_TYPES.MatchVariant && { args, wrap, format }
548
+ )
549
+ )
550
+
551
+ if (typeof result === 'string' && !isValidVariantFormatString(result)) {
552
+ throw new Error(
553
+ `Your custom variant \`${variantName}\` has an invalid format string. Make sure it's an at-rule or contains a \`&\` placeholder.`
554
+ )
555
+ }
556
+
557
+ if (Array.isArray(result)) {
558
+ return result
559
+ .filter((variant) => typeof variant === 'string')
560
+ .map((variant) => parseVariant(variant))
561
+ }
562
+
563
+ // result may be undefined with legacy variants that use APIs like `modifySelectors`
564
+ // result may also be a postcss node if someone was returning the result from `modifySelectors`
565
+ return result && typeof result === 'string' && parseVariant(result)(api)
566
+ }
567
+ }
568
+
569
+ if (!isValidVariantFormatString(variantFunction)) {
570
+ throw new Error(
571
+ `Your custom variant \`${variantName}\` has an invalid format string. Make sure it's an at-rule or contains a \`&\` placeholder.`
572
+ )
573
+ }
574
+
575
+ return parseVariant(variantFunction)
576
+ })
577
+
578
+ insertInto(variantList, variantName, options)
579
+ variantMap.set(variantName, variantFunctions)
580
+ context.variantOptions.set(variantName, options)
581
+ },
582
+ matchVariant(variant, variantFn, options) {
583
+ // A unique identifier that "groups" these variants together.
584
+ // This is for internal use only which is why it is not present in the types
585
+ let id = options?.id ?? ++variantIdentifier
586
+ let isSpecial = variant === '@'
587
+
588
+ let modifiersEnabled = flagEnabled(tailwindConfig, 'generalizedModifiers')
589
+
590
+ for (let [key, value] of Object.entries(options?.values ?? {})) {
591
+ if (key === 'DEFAULT') continue
592
+
593
+ api.addVariant(
594
+ isSpecial ? `${variant}${key}` : `${variant}-${key}`,
595
+ ({ args, container }) => {
596
+ return variantFn(
597
+ value,
598
+ modifiersEnabled ? { modifier: args?.modifier, container } : { container }
599
+ )
600
+ },
601
+
602
+ {
603
+ ...options,
604
+ value,
605
+ id,
606
+ type: VARIANT_TYPES.MatchVariant,
607
+ variantInfo: VARIANT_INFO.Base,
608
+ }
609
+ )
610
+ }
611
+
612
+ let hasDefault = 'DEFAULT' in (options?.values ?? {})
613
+
614
+ api.addVariant(
615
+ variant,
616
+ ({ args, container }) => {
617
+ if (args?.value === sharedState.NONE && !hasDefault) {
618
+ return null
619
+ }
620
+
621
+ return variantFn(
622
+ args?.value === sharedState.NONE
623
+ ? options.values.DEFAULT
624
+ : // Falling back to args if it is a string, otherwise '' for older intellisense
625
+ // (JetBrains) plugins.
626
+ args?.value ?? (typeof args === 'string' ? args : ''),
627
+ modifiersEnabled ? { modifier: args?.modifier, container } : { container }
628
+ )
629
+ },
630
+ {
631
+ ...options,
632
+ id,
633
+ type: VARIANT_TYPES.MatchVariant,
634
+ variantInfo: VARIANT_INFO.Dynamic,
635
+ }
636
+ )
637
+ },
342
638
  }
639
+
640
+ return api
343
641
  }
344
642
 
345
643
  let fileModifiedMapCache = new WeakMap()
@@ -352,6 +650,7 @@ export function getFileModifiedMap(context) {
352
650
 
353
651
  function trackModified(files, fileModifiedMap) {
354
652
  let changed = false
653
+ let mtimesToCommit = new Map()
355
654
 
356
655
  for (let file of files) {
357
656
  if (!file) continue
@@ -359,16 +658,23 @@ function trackModified(files, fileModifiedMap) {
359
658
  let parsed = url.parse(file)
360
659
  let pathname = parsed.hash ? parsed.href.replace(parsed.hash, '') : parsed.href
361
660
  pathname = parsed.search ? pathname.replace(parsed.search, '') : pathname
362
- let newModified = fs.statSync(decodeURIComponent(pathname)).mtimeMs
661
+ let newModified = fs.statSync(decodeURIComponent(pathname), { throwIfNoEntry: false })?.mtimeMs
662
+ if (!newModified) {
663
+ // It could happen that a file is passed in that doesn't exist. E.g.:
664
+ // postcss-cli will provide you a fake path when reading from stdin. This
665
+ // path then looks like /path-to-your-project/stdin In that case we just
666
+ // want to ignore it and don't track changes at all.
667
+ continue
668
+ }
363
669
 
364
670
  if (!fileModifiedMap.has(file) || newModified > fileModifiedMap.get(file)) {
365
671
  changed = true
366
672
  }
367
673
 
368
- fileModifiedMap.set(file, newModified)
674
+ mtimesToCommit.set(file, newModified)
369
675
  }
370
676
 
371
- return changed
677
+ return [changed, mtimesToCommit]
372
678
  }
373
679
 
374
680
  function extractVariantAtRules(node) {
@@ -405,34 +711,25 @@ function collectLayerPlugins(root) {
405
711
  } else if (layerRule.params === 'components') {
406
712
  for (let node of layerRule.nodes) {
407
713
  layerPlugins.push(function ({ addComponents }) {
408
- addComponents(node, { respectPrefix: false })
714
+ addComponents(node, { respectPrefix: false, preserveSource: true })
409
715
  })
410
716
  }
411
717
  layerRule.remove()
412
718
  } else if (layerRule.params === 'utilities') {
413
719
  for (let node of layerRule.nodes) {
414
720
  layerPlugins.push(function ({ addUtilities }) {
415
- addUtilities(node, { respectPrefix: false })
721
+ addUtilities(node, { respectPrefix: false, preserveSource: true })
416
722
  })
417
723
  }
418
724
  layerRule.remove()
419
725
  }
420
726
  })
421
727
 
422
- root.walkRules((rule) => {
423
- // At this point it is safe to include all the left-over css from the
424
- // user's css file. This is because the `@tailwind` and `@layer` directives
425
- // will already be handled and will be removed from the css tree.
426
- layerPlugins.push(function ({ addUserCss }) {
427
- addUserCss(rule, { respectPrefix: false })
428
- })
429
- })
430
-
431
728
  return layerPlugins
432
729
  }
433
730
 
434
- function resolvePlugins(context, tailwindDirectives, root) {
435
- let corePluginList = Object.entries(corePlugins)
731
+ function resolvePlugins(context, root) {
732
+ let corePluginList = Object.entries({ ...variantPlugins, ...corePlugins })
436
733
  .map(([name, plugin]) => {
437
734
  if (!context.tailwindConfig.corePlugins.includes(name)) {
438
735
  return null
@@ -450,16 +747,25 @@ function resolvePlugins(context, tailwindDirectives, root) {
450
747
  return typeof plugin === 'function' ? plugin : plugin.handler
451
748
  })
452
749
 
453
- let layerPlugins = collectLayerPlugins(root, tailwindDirectives)
750
+ let layerPlugins = collectLayerPlugins(root)
454
751
 
455
752
  // TODO: This is a workaround for backwards compatibility, since custom variants
456
753
  // were historically sorted before screen/stackable variants.
457
- let beforeVariants = [corePlugins['pseudoElementVariants'], corePlugins['pseudoClassVariants']]
754
+ let beforeVariants = [
755
+ variantPlugins['pseudoElementVariants'],
756
+ variantPlugins['pseudoClassVariants'],
757
+ variantPlugins['ariaVariants'],
758
+ variantPlugins['dataVariants'],
759
+ ]
458
760
  let afterVariants = [
459
- corePlugins['directionVariants'],
460
- corePlugins['reducedMotionVariants'],
461
- corePlugins['darkVariants'],
462
- corePlugins['screenVariants'],
761
+ variantPlugins['supportsVariants'],
762
+ variantPlugins['directionVariants'],
763
+ variantPlugins['reducedMotionVariants'],
764
+ variantPlugins['prefersContrastVariants'],
765
+ variantPlugins['darkVariants'],
766
+ variantPlugins['printVariant'],
767
+ variantPlugins['screenVariants'],
768
+ variantPlugins['orientationVariants'],
463
769
  ]
464
770
 
465
771
  return [...corePluginList, ...beforeVariants, ...userPlugins, ...afterVariants, ...layerPlugins]
@@ -468,12 +774,10 @@ function resolvePlugins(context, tailwindDirectives, root) {
468
774
  function registerPlugins(plugins, context) {
469
775
  let variantList = []
470
776
  let variantMap = new Map()
471
- let offsets = {
472
- base: 0n,
473
- components: 0n,
474
- utilities: 0n,
475
- user: 0n,
476
- }
777
+ context.variantMap = variantMap
778
+
779
+ let offsets = new Offsets()
780
+ context.offsets = offsets
477
781
 
478
782
  let classList = new Set()
479
783
 
@@ -494,145 +798,437 @@ function registerPlugins(plugins, context) {
494
798
  }
495
799
  }
496
800
 
497
- let highestOffset = ((args) => args.reduce((m, e) => (e > m ? e : m)))([
498
- offsets.base,
499
- offsets.components,
500
- offsets.utilities,
501
- offsets.user,
502
- ])
503
- let reservedBits = BigInt(highestOffset.toString(2).length)
504
-
505
- context.layerOrder = {
506
- base: (1n << reservedBits) << 0n,
507
- components: (1n << reservedBits) << 1n,
508
- utilities: (1n << reservedBits) << 2n,
509
- user: (1n << reservedBits) << 3n,
510
- }
511
-
512
- reservedBits += 4n
513
-
514
- let offset = 0
515
- context.variantOrder = new Map(
516
- variantList
517
- .map((variant, i) => {
518
- let variantFunctions = variantMap.get(variant).length
519
- let bits = (1n << BigInt(i + offset)) << reservedBits
520
- offset += variantFunctions - 1
521
- return [variant, bits]
522
- })
523
- .sort(([, a], [, z]) => bigSign(a - z))
524
- )
525
-
526
- context.minimumScreen = [...context.variantOrder.values()].shift()
801
+ // Make sure to record bit masks for every variant
802
+ offsets.recordVariants(variantList, (variant) => variantMap.get(variant).length)
527
803
 
528
804
  // Build variantMap
529
805
  for (let [variantName, variantFunctions] of variantMap.entries()) {
530
- let sort = context.variantOrder.get(variantName)
531
806
  context.variantMap.set(
532
807
  variantName,
533
- variantFunctions.map((variantFunction, idx) => [sort << BigInt(idx), variantFunction])
808
+ variantFunctions.map((variantFunction, idx) => [
809
+ offsets.forVariant(variantName, idx),
810
+ variantFunction,
811
+ ])
534
812
  )
535
813
  }
536
814
 
537
- //
538
- let warnedAbout = new Set([])
539
- context.safelist = function () {
540
- let safelist = (context.tailwindConfig.safelist ?? []).filter(Boolean)
541
- if (safelist.length <= 0) return []
542
-
543
- let output = []
815
+ let safelist = (context.tailwindConfig.safelist ?? []).filter(Boolean)
816
+ if (safelist.length > 0) {
544
817
  let checks = []
545
818
 
546
819
  for (let value of safelist) {
547
820
  if (typeof value === 'string') {
548
- output.push(value)
821
+ context.changedContent.push({ content: value, extension: 'html' })
549
822
  continue
550
823
  }
551
824
 
552
825
  if (value instanceof RegExp) {
553
- if (!warnedAbout.has('root-regex')) {
554
- log.warn([
555
- // TODO: Improve this warning message
556
- 'RegExp in the safelist option is not supported.',
557
- 'Please use the object syntax instead: https://tailwindcss.com/docs/...',
558
- ])
559
- warnedAbout.add('root-regex')
560
- }
826
+ log.warn('root-regex', [
827
+ 'Regular expressions in `safelist` work differently in Tailwind CSS v3.0.',
828
+ 'Update your `safelist` configuration to eliminate this warning.',
829
+ 'https://tailwindcss.com/docs/content-configuration#safelisting-classes',
830
+ ])
561
831
  continue
562
832
  }
563
833
 
564
834
  checks.push(value)
565
835
  }
566
836
 
567
- if (checks.length <= 0) return output.map((value) => ({ raw: value, extension: 'html' }))
837
+ if (checks.length > 0) {
838
+ let patternMatchingCount = new Map()
839
+ let prefixLength = context.tailwindConfig.prefix.length
840
+ let checkImportantUtils = checks.some((check) => check.pattern.source.includes('!'))
841
+
842
+ for (let util of classList) {
843
+ let utils = Array.isArray(util)
844
+ ? (() => {
845
+ let [utilName, options] = util
846
+ let values = Object.keys(options?.values ?? {})
847
+ let classes = values.map((value) => formatClass(utilName, value))
848
+
849
+ if (options?.supportsNegativeValues) {
850
+ // This is the normal negated version
851
+ // e.g. `-inset-1` or `-tw-inset-1`
852
+ classes = [...classes, ...classes.map((cls) => '-' + cls)]
853
+
854
+ // This is the negated version *after* the prefix
855
+ // e.g. `tw--inset-1`
856
+ // The prefix is already attached to util name
857
+ // So we add the negative after the prefix
858
+ classes = [
859
+ ...classes,
860
+ ...classes.map(
861
+ (cls) => cls.slice(0, prefixLength) + '-' + cls.slice(prefixLength)
862
+ ),
863
+ ]
864
+ }
865
+
866
+ if (options.types.some(({ type }) => type === 'color')) {
867
+ classes = [
868
+ ...classes,
869
+ ...classes.flatMap((cls) =>
870
+ Object.keys(context.tailwindConfig.theme.opacity).map(
871
+ (opacity) => `${cls}/${opacity}`
872
+ )
873
+ ),
874
+ ]
875
+ }
876
+
877
+ if (checkImportantUtils && options?.respectImportant) {
878
+ classes = [...classes, ...classes.map((cls) => '!' + cls)]
879
+ }
880
+
881
+ return classes
882
+ })()
883
+ : [util]
884
+
885
+ for (let util of utils) {
886
+ for (let { pattern, variants = [] } of checks) {
887
+ // RegExp with the /g flag are stateful, so let's reset the last
888
+ // index pointer to reset the state.
889
+ pattern.lastIndex = 0
890
+
891
+ if (!patternMatchingCount.has(pattern)) {
892
+ patternMatchingCount.set(pattern, 0)
893
+ }
894
+
895
+ if (!pattern.test(util)) continue
896
+
897
+ patternMatchingCount.set(pattern, patternMatchingCount.get(pattern) + 1)
898
+
899
+ context.changedContent.push({ content: util, extension: 'html' })
900
+ for (let variant of variants) {
901
+ context.changedContent.push({
902
+ content: variant + context.tailwindConfig.separator + util,
903
+ extension: 'html',
904
+ })
905
+ }
906
+ }
907
+ }
908
+ }
909
+
910
+ for (let [regex, count] of patternMatchingCount.entries()) {
911
+ if (count !== 0) continue
912
+
913
+ log.warn([
914
+ `The safelist pattern \`${regex}\` doesn't match any Tailwind CSS classes.`,
915
+ 'Fix this pattern or remove it from your `safelist` configuration.',
916
+ 'https://tailwindcss.com/docs/content-configuration#safelisting-classes',
917
+ ])
918
+ }
919
+ }
920
+ }
921
+
922
+ let darkClassName = [].concat(context.tailwindConfig.darkMode ?? 'media')[1] ?? 'dark'
923
+
924
+ // A list of utilities that are used by certain Tailwind CSS utilities but
925
+ // that don't exist on their own. This will result in them "not existing" and
926
+ // sorting could be weird since you still require them in order to make the
927
+ // host utilities work properly. (Thanks Biology)
928
+ let parasiteUtilities = [
929
+ prefix(context, darkClassName),
930
+ prefix(context, 'group'),
931
+ prefix(context, 'peer'),
932
+ ]
933
+ context.getClassOrder = function getClassOrder(classes) {
934
+ // Sort classes so they're ordered in a deterministic manner
935
+ let sorted = [...classes].sort((a, z) => {
936
+ if (a === z) return 0
937
+ if (a < z) return -1
938
+ return 1
939
+ })
940
+
941
+ // Non-util classes won't be generated, so we default them to null
942
+ let sortedClassNames = new Map(sorted.map((className) => [className, null]))
943
+
944
+ // Sort all classes in order
945
+ // Non-tailwind classes won't be generated and will be left as `null`
946
+ let rules = generateRules(new Set(sorted), context)
947
+ rules = context.offsets.sort(rules)
948
+
949
+ let idx = BigInt(parasiteUtilities.length)
950
+
951
+ for (const [, rule] of rules) {
952
+ sortedClassNames.set(rule.raws.tailwind.candidate, idx++)
953
+ }
954
+
955
+ return classes.map((className) => {
956
+ let order = sortedClassNames.get(className) ?? null
957
+ let parasiteIndex = parasiteUtilities.indexOf(className)
568
958
 
569
- let patternMatchingCount = new Map()
959
+ if (order === null && parasiteIndex !== -1) {
960
+ // This will make sure that it is at the very beginning of the
961
+ // `components` layer which technically means 'before any
962
+ // components'.
963
+ order = BigInt(parasiteIndex)
964
+ }
965
+
966
+ return [className, order]
967
+ })
968
+ }
969
+
970
+ // Generate a list of strings for autocompletion purposes, e.g.
971
+ // ['uppercase', 'lowercase', ...]
972
+ context.getClassList = function getClassList(options = {}) {
973
+ let output = []
570
974
 
571
975
  for (let util of classList) {
572
- let utils = Array.isArray(util)
573
- ? (() => {
574
- let [utilName, options] = util
575
- return Object.keys(options?.values ?? {}).map((value) => formatClass(utilName, value))
576
- })()
577
- : [util]
578
-
579
- for (let util of utils) {
580
- for (let { pattern, variants = [] } of checks) {
581
- // RegExp with the /g flag are stateful, so let's reset the last
582
- // index pointer to reset the state.
583
- pattern.lastIndex = 0
584
-
585
- if (!patternMatchingCount.has(pattern)) {
586
- patternMatchingCount.set(pattern, 0)
587
- }
976
+ if (Array.isArray(util)) {
977
+ let [utilName, utilOptions] = util
978
+ let negativeClasses = []
979
+
980
+ let modifiers = Object.keys(utilOptions?.modifiers ?? {})
588
981
 
589
- if (!pattern.test(util)) continue
982
+ if (utilOptions?.types?.some(({ type }) => type === 'color')) {
983
+ modifiers.push(...Object.keys(context.tailwindConfig.theme.opacity ?? {}))
984
+ }
590
985
 
591
- patternMatchingCount.set(pattern, patternMatchingCount.get(pattern) + 1)
986
+ let metadata = { modifiers }
987
+ let includeMetadata = options.includeMetadata && modifiers.length > 0
592
988
 
593
- output.push(util)
594
- for (let variant of variants) {
595
- output.push(variant + context.tailwindConfig.separator + util)
989
+ for (let [key, value] of Object.entries(utilOptions?.values ?? {})) {
990
+ // Ignore undefined and null values
991
+ if (value == null) {
992
+ continue
993
+ }
994
+
995
+ let cls = formatClass(utilName, key)
996
+ output.push(includeMetadata ? [cls, metadata] : cls)
997
+
998
+ if (utilOptions?.supportsNegativeValues && negateValue(value)) {
999
+ let cls = formatClass(utilName, `-${key}`)
1000
+ negativeClasses.push(includeMetadata ? [cls, metadata] : cls)
596
1001
  }
597
1002
  }
1003
+
1004
+ output.push(...negativeClasses)
1005
+ } else {
1006
+ output.push(util)
598
1007
  }
599
1008
  }
600
1009
 
601
- for (let [regex, count] of patternMatchingCount.entries()) {
602
- if (count !== 0) continue
1010
+ return output
1011
+ }
603
1012
 
604
- log.warn([
605
- // TODO: Improve this warning message
606
- `You have a regex pattern in your "safelist" config (${regex}) that doesn't match any utilities.`,
607
- 'For more info, visit https://tailwindcss.com/docs/...',
608
- ])
1013
+ // Generate a list of available variants with meta information of the type of variant.
1014
+ context.getVariants = function getVariants() {
1015
+ let result = []
1016
+ for (let [name, options] of context.variantOptions.entries()) {
1017
+ if (options.variantInfo === VARIANT_INFO.Base) continue
1018
+
1019
+ result.push({
1020
+ name,
1021
+ isArbitrary: options.type === Symbol.for('MATCH_VARIANT'),
1022
+ values: Object.keys(options.values ?? {}),
1023
+ hasDash: name !== '@',
1024
+ selectors({ modifier, value } = {}) {
1025
+ let candidate = '__TAILWIND_PLACEHOLDER__'
1026
+
1027
+ let rule = postcss.rule({ selector: `.${candidate}` })
1028
+ let container = postcss.root({ nodes: [rule.clone()] })
1029
+
1030
+ let before = container.toString()
1031
+
1032
+ let fns = (context.variantMap.get(name) ?? []).flatMap(([_, fn]) => fn)
1033
+ let formatStrings = []
1034
+ for (let fn of fns) {
1035
+ let localFormatStrings = []
1036
+
1037
+ let api = {
1038
+ args: { modifier, value: options.values?.[value] ?? value },
1039
+ separator: context.tailwindConfig.separator,
1040
+ modifySelectors(modifierFunction) {
1041
+ // Run the modifierFunction over each rule
1042
+ container.each((rule) => {
1043
+ if (rule.type !== 'rule') {
1044
+ return
1045
+ }
1046
+
1047
+ rule.selectors = rule.selectors.map((selector) => {
1048
+ return modifierFunction({
1049
+ get className() {
1050
+ return getClassNameFromSelector(selector)
1051
+ },
1052
+ selector,
1053
+ })
1054
+ })
1055
+ })
1056
+
1057
+ return container
1058
+ },
1059
+ format(str) {
1060
+ localFormatStrings.push(str)
1061
+ },
1062
+ wrap(wrapper) {
1063
+ localFormatStrings.push(`@${wrapper.name} ${wrapper.params} { & }`)
1064
+ },
1065
+ container,
1066
+ }
1067
+
1068
+ let ruleWithVariant = fn(api)
1069
+ if (localFormatStrings.length > 0) {
1070
+ formatStrings.push(localFormatStrings)
1071
+ }
1072
+
1073
+ if (Array.isArray(ruleWithVariant)) {
1074
+ for (let variantFunction of ruleWithVariant) {
1075
+ localFormatStrings = []
1076
+ variantFunction(api)
1077
+ formatStrings.push(localFormatStrings)
1078
+ }
1079
+ }
1080
+ }
1081
+
1082
+ // Reverse engineer the result of the `container`
1083
+ let manualFormatStrings = []
1084
+ let after = container.toString()
1085
+
1086
+ if (before !== after) {
1087
+ // Figure out all selectors
1088
+ container.walkRules((rule) => {
1089
+ let modified = rule.selector
1090
+
1091
+ // Rebuild the base selector, this is what plugin authors would do
1092
+ // as well. E.g.: `${variant}${separator}${className}`.
1093
+ // However, plugin authors probably also prepend or append certain
1094
+ // classes, pseudos, ids, ...
1095
+ let rebuiltBase = selectorParser((selectors) => {
1096
+ selectors.walkClasses((classNode) => {
1097
+ classNode.value = `${name}${context.tailwindConfig.separator}${classNode.value}`
1098
+ })
1099
+ }).processSync(modified)
1100
+
1101
+ // Now that we know the original selector, the new selector, and
1102
+ // the rebuild part in between, we can replace the part that plugin
1103
+ // authors need to rebuild with `&`, and eventually store it in the
1104
+ // collectedFormats. Similar to what `format('...')` would do.
1105
+ //
1106
+ // E.g.:
1107
+ // variant: foo
1108
+ // selector: .markdown > p
1109
+ // modified (by plugin): .foo .foo\\:markdown > p
1110
+ // rebuiltBase (internal): .foo\\:markdown > p
1111
+ // format: .foo &
1112
+ manualFormatStrings.push(modified.replace(rebuiltBase, '&').replace(candidate, '&'))
1113
+ })
1114
+
1115
+ // Figure out all atrules
1116
+ container.walkAtRules((atrule) => {
1117
+ manualFormatStrings.push(`@${atrule.name} (${atrule.params}) { & }`)
1118
+ })
1119
+ }
1120
+
1121
+ let isArbitraryVariant = !(value in (options.values ?? {}))
1122
+
1123
+ formatStrings = formatStrings.map((format) =>
1124
+ format.map((str) => ({
1125
+ format: str,
1126
+ isArbitraryVariant,
1127
+ }))
1128
+ )
1129
+
1130
+ manualFormatStrings = manualFormatStrings.map((format) => ({
1131
+ format,
1132
+ isArbitraryVariant,
1133
+ }))
1134
+
1135
+ let opts = {
1136
+ candidate,
1137
+ context,
1138
+ }
1139
+
1140
+ let result = formatStrings.map((formats) =>
1141
+ finalizeSelector(`.${candidate}`, formatVariantSelector(formats, opts), opts)
1142
+ .replace(`.${candidate}`, '&')
1143
+ .replace('{ & }', '')
1144
+ .trim()
1145
+ )
1146
+
1147
+ if (manualFormatStrings.length > 0) {
1148
+ result.push(
1149
+ formatVariantSelector(manualFormatStrings, opts)
1150
+ .toString()
1151
+ .replace(`.${candidate}`, '&')
1152
+ )
1153
+ }
1154
+
1155
+ return result
1156
+ },
1157
+ })
609
1158
  }
610
1159
 
611
- return output.map((value) => ({ raw: value, extension: 'html' }))
1160
+ return result
612
1161
  }
613
1162
  }
614
1163
 
615
- export function createContext(
616
- tailwindConfig,
617
- changedContent = [],
618
- tailwindDirectives = new Set(),
619
- root = postcss.root()
620
- ) {
1164
+ /**
1165
+ * Mark as class as retroactively invalid
1166
+ *
1167
+ *
1168
+ * @param {string} candidate
1169
+ */
1170
+ function markInvalidUtilityCandidate(context, candidate) {
1171
+ if (!context.classCache.has(candidate)) {
1172
+ return
1173
+ }
1174
+
1175
+ // Mark this as not being a real utility
1176
+ context.notClassCache.add(candidate)
1177
+
1178
+ // Remove it from any candidate-specific caches
1179
+ context.classCache.delete(candidate)
1180
+ context.applyClassCache.delete(candidate)
1181
+ context.candidateRuleMap.delete(candidate)
1182
+ context.candidateRuleCache.delete(candidate)
1183
+
1184
+ // Ensure the stylesheet gets rebuilt
1185
+ context.stylesheetCache = null
1186
+ }
1187
+
1188
+ /**
1189
+ * Mark as class as retroactively invalid
1190
+ *
1191
+ * @param {import('postcss').Node} node
1192
+ */
1193
+ function markInvalidUtilityNode(context, node) {
1194
+ let candidate = node.raws.tailwind.candidate
1195
+
1196
+ if (!candidate) {
1197
+ return
1198
+ }
1199
+
1200
+ for (const entry of context.ruleCache) {
1201
+ if (entry[1].raws.tailwind.candidate === candidate) {
1202
+ context.ruleCache.delete(entry)
1203
+ // context.postCssNodeCache.delete(node)
1204
+ }
1205
+ }
1206
+
1207
+ markInvalidUtilityCandidate(context, candidate)
1208
+ }
1209
+
1210
+ export function createContext(tailwindConfig, changedContent = [], root = postcss.root()) {
621
1211
  let context = {
622
1212
  disposables: [],
623
1213
  ruleCache: new Set(),
1214
+ candidateRuleCache: new Map(),
624
1215
  classCache: new Map(),
625
1216
  applyClassCache: new Map(),
626
- notClassCache: new Set(),
1217
+ // Seed the not class cache with the blocklist (which is only strings)
1218
+ notClassCache: new Set(tailwindConfig.blocklist ?? []),
627
1219
  postCssNodeCache: new Map(),
628
1220
  candidateRuleMap: new Map(),
629
1221
  tailwindConfig,
630
1222
  changedContent: changedContent,
631
1223
  variantMap: new Map(),
632
1224
  stylesheetCache: null,
1225
+ variantOptions: new Map(),
1226
+
1227
+ markInvalidUtilityCandidate: (candidate) => markInvalidUtilityCandidate(context, candidate),
1228
+ markInvalidUtilityNode: (node) => markInvalidUtilityNode(context, node),
633
1229
  }
634
1230
 
635
- let resolvedPlugins = resolvePlugins(context, tailwindDirectives, root)
1231
+ let resolvedPlugins = resolvePlugins(context, root)
636
1232
  registerPlugins(resolvedPlugins, context)
637
1233
 
638
1234
  return context
@@ -643,7 +1239,6 @@ let configContextMap = sharedState.configContextMap
643
1239
  let contextSourcesMap = sharedState.contextSourcesMap
644
1240
 
645
1241
  export function getContext(
646
- tailwindDirectives,
647
1242
  root,
648
1243
  result,
649
1244
  tailwindConfig,
@@ -668,15 +1263,17 @@ export function getContext(
668
1263
  existingContext = context
669
1264
  }
670
1265
 
1266
+ let cssDidChange = hasContentChanged(sourcePath, root)
1267
+
671
1268
  // If there's already a context in the cache and we don't need to
672
1269
  // reset the context, return the cached context.
673
1270
  if (existingContext) {
674
- let contextDependenciesChanged = trackModified(
1271
+ let [contextDependenciesChanged, mtimesToCommit] = trackModified(
675
1272
  [...contextDependencies],
676
1273
  getFileModifiedMap(existingContext)
677
1274
  )
678
- if (!contextDependenciesChanged) {
679
- return [existingContext, false]
1275
+ if (!contextDependenciesChanged && !cssDidChange) {
1276
+ return [existingContext, false, mtimesToCommit]
680
1277
  }
681
1278
  }
682
1279
 
@@ -705,9 +1302,13 @@ export function getContext(
705
1302
 
706
1303
  env.DEBUG && console.log('Setting up new context...')
707
1304
 
708
- let context = createContext(tailwindConfig, [], tailwindDirectives, root)
1305
+ let context = createContext(tailwindConfig, [], root)
1306
+
1307
+ Object.assign(context, {
1308
+ userConfigPath,
1309
+ })
709
1310
 
710
- trackModified([...contextDependencies], getFileModifiedMap(context))
1311
+ let [, mtimesToCommit] = trackModified([...contextDependencies], getFileModifiedMap(context))
711
1312
 
712
1313
  // ---
713
1314
 
@@ -722,5 +1323,5 @@ export function getContext(
722
1323
 
723
1324
  contextSourcesMap.get(context).add(sourcePath)
724
1325
 
725
- return [context, true]
1326
+ return [context, true, mtimesToCommit]
726
1327
  }