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.
- package/LICENSE +1 -2
- package/README.md +15 -7
- package/colors.d.ts +3 -0
- package/colors.js +2 -304
- package/defaultConfig.d.ts +3 -0
- package/defaultConfig.js +2 -4
- package/defaultTheme.d.ts +4 -0
- package/defaultTheme.js +2 -4
- package/lib/cli/build/deps.js +54 -0
- package/lib/cli/build/index.js +52 -0
- package/lib/cli/build/plugin.js +376 -0
- package/lib/cli/build/utils.js +78 -0
- package/lib/cli/build/watching.js +180 -0
- package/lib/cli/help/index.js +71 -0
- package/lib/cli/index.js +230 -0
- package/lib/cli/init/index.js +61 -0
- package/lib/cli-peer-dependencies.js +22 -14
- package/lib/cli.js +4 -762
- package/lib/corePluginList.js +182 -5
- package/lib/corePlugins.js +4109 -2952
- package/lib/css/preflight.css +24 -9
- package/lib/featureFlags.js +68 -50
- package/lib/index.js +5 -30
- package/lib/lib/cacheInvalidation.js +90 -0
- package/lib/lib/collapseAdjacentRules.js +52 -36
- package/lib/lib/collapseDuplicateDeclarations.js +83 -0
- package/lib/lib/content.js +177 -0
- package/lib/lib/defaultExtractor.js +241 -0
- package/lib/lib/detectNesting.js +39 -17
- package/lib/lib/evaluateTailwindFunctions.js +203 -161
- package/lib/lib/expandApplyAtRules.js +503 -221
- package/lib/lib/expandTailwindAtRules.js +255 -243
- package/lib/lib/findAtConfigPath.js +44 -0
- package/lib/lib/generateRules.js +831 -317
- package/lib/lib/getModuleDependencies.js +93 -49
- package/lib/lib/load-config.js +36 -0
- package/lib/lib/normalizeTailwindDirectives.js +79 -60
- package/lib/lib/offsets.js +304 -0
- package/lib/lib/partitionApplyAtRules.js +56 -0
- package/lib/lib/regex.js +60 -0
- package/lib/lib/remap-bitfield.js +87 -0
- package/lib/lib/resolveDefaultsAtRules.js +150 -94
- package/lib/lib/setupContextUtils.js +1197 -685
- package/lib/lib/setupTrackingContext.js +150 -177
- package/lib/lib/sharedState.js +70 -21
- package/lib/lib/substituteScreenAtRules.js +26 -28
- package/lib/oxide/cli/build/deps.js +81 -0
- package/lib/oxide/cli/build/index.js +51 -0
- package/lib/oxide/cli/build/plugin.js +373 -0
- package/lib/oxide/cli/build/utils.js +77 -0
- package/lib/oxide/cli/build/watching.js +177 -0
- package/lib/oxide/cli/help/index.js +70 -0
- package/lib/oxide/cli/index.js +214 -0
- package/lib/oxide/cli/init/index.js +50 -0
- package/lib/oxide/cli.js +5 -0
- package/lib/oxide/postcss-plugin.js +2 -0
- package/lib/plugin.js +98 -0
- package/{nesting → lib/postcss-plugins/nesting}/README.md +2 -2
- package/lib/postcss-plugins/nesting/index.js +19 -0
- package/lib/postcss-plugins/nesting/plugin.js +87 -0
- package/lib/processTailwindFeatures.js +58 -56
- package/lib/public/colors.js +353 -0
- package/lib/public/create-plugin.js +15 -0
- package/lib/public/default-config.js +16 -0
- package/lib/public/default-theme.js +16 -0
- package/lib/public/load-config.js +10 -0
- package/lib/public/resolve-config.js +22 -0
- package/lib/util/applyImportantSelector.js +22 -0
- package/lib/util/bigSign.js +7 -6
- package/lib/util/buildMediaQuery.js +21 -32
- package/lib/util/cloneDeep.js +16 -14
- package/lib/util/cloneNodes.js +29 -15
- package/lib/util/color.js +104 -66
- package/lib/util/configurePlugins.js +17 -15
- package/lib/util/createPlugin.js +23 -26
- package/lib/util/createUtilityPlugin.js +46 -46
- package/lib/util/dataTypes.js +266 -0
- package/lib/util/defaults.js +20 -15
- package/lib/util/escapeClassName.js +18 -17
- package/lib/util/escapeCommas.js +7 -6
- package/lib/util/flattenColorPalette.js +13 -12
- package/lib/util/formatVariantSelector.js +341 -0
- package/lib/util/getAllConfigs.js +44 -18
- package/lib/util/hashConfig.js +15 -12
- package/lib/util/isKeyframeRule.js +7 -6
- package/lib/util/isPlainObject.js +11 -11
- package/lib/util/isSyntacticallyValidPropertyValue.js +72 -0
- package/lib/util/log.js +52 -33
- package/lib/util/nameClass.js +35 -29
- package/lib/util/negateValue.js +31 -17
- package/lib/util/normalizeConfig.js +294 -0
- package/lib/util/normalizeScreens.js +170 -0
- package/lib/util/parseAnimationValue.js +85 -54
- package/lib/util/parseBoxShadowValue.js +84 -0
- package/lib/util/parseDependency.js +41 -70
- package/lib/util/parseGlob.js +34 -0
- package/lib/util/parseObjectStyles.js +30 -24
- package/lib/util/pluginUtils.js +234 -288
- package/lib/util/prefixSelector.js +33 -19
- package/lib/util/removeAlphaVariables.js +29 -0
- package/lib/util/resolveConfig.js +221 -256
- package/lib/util/resolveConfigPath.js +55 -48
- package/lib/util/responsive.js +18 -14
- package/lib/util/splitAtTopLevelOnly.js +49 -0
- package/lib/util/tap.js +8 -7
- package/lib/util/toColorValue.js +7 -6
- package/lib/util/toPath.js +27 -8
- package/lib/util/transformThemeValue.js +67 -28
- package/lib/util/validateConfig.js +24 -0
- package/lib/util/validateFormalSyntax.js +24 -0
- package/lib/util/withAlphaVariable.js +67 -57
- package/loadConfig.d.ts +4 -0
- package/loadConfig.js +2 -0
- package/nesting/index.js +2 -12
- package/package.json +69 -66
- package/peers/index.js +76328 -84169
- package/plugin.d.ts +11 -0
- package/plugin.js +1 -2
- package/resolveConfig.d.ts +12 -0
- package/resolveConfig.js +2 -7
- package/scripts/create-plugin-list.js +2 -2
- package/scripts/generate-types.js +105 -0
- package/scripts/release-channel.js +18 -0
- package/scripts/release-notes.js +21 -0
- package/scripts/swap-engines.js +40 -0
- package/scripts/type-utils.js +27 -0
- package/src/cli/build/deps.js +56 -0
- package/src/cli/build/index.js +49 -0
- package/src/cli/build/plugin.js +444 -0
- package/src/cli/build/utils.js +76 -0
- package/src/cli/build/watching.js +229 -0
- package/src/cli/help/index.js +70 -0
- package/src/cli/index.js +216 -0
- package/src/cli/init/index.js +79 -0
- package/src/cli-peer-dependencies.js +7 -1
- package/src/cli.js +4 -756
- package/src/corePluginList.js +1 -1
- package/src/corePlugins.js +2526 -1956
- package/src/css/preflight.css +24 -9
- package/src/featureFlags.js +33 -10
- package/src/index.js +4 -33
- package/src/lib/cacheInvalidation.js +52 -0
- package/src/lib/collapseAdjacentRules.js +21 -2
- package/src/lib/collapseDuplicateDeclarations.js +93 -0
- package/src/lib/content.js +208 -0
- package/src/lib/defaultExtractor.js +217 -0
- package/src/lib/detectNesting.js +30 -3
- package/src/lib/evaluateTailwindFunctions.js +84 -10
- package/src/lib/expandApplyAtRules.js +509 -153
- package/src/lib/expandTailwindAtRules.js +125 -104
- package/src/lib/findAtConfigPath.js +48 -0
- package/src/lib/generateRules.js +678 -70
- package/src/lib/getModuleDependencies.js +70 -30
- package/src/lib/load-config.ts +27 -0
- package/src/lib/normalizeTailwindDirectives.js +10 -3
- package/src/lib/offsets.js +373 -0
- package/src/lib/partitionApplyAtRules.js +52 -0
- package/src/lib/regex.js +74 -0
- package/src/lib/remap-bitfield.js +82 -0
- package/src/lib/resolveDefaultsAtRules.js +105 -47
- package/src/lib/setupContextUtils.js +848 -247
- package/src/lib/setupTrackingContext.js +53 -64
- package/src/lib/sharedState.js +60 -6
- package/src/lib/substituteScreenAtRules.js +6 -3
- package/src/oxide/cli/build/deps.ts +91 -0
- package/src/oxide/cli/build/index.ts +47 -0
- package/src/oxide/cli/build/plugin.ts +442 -0
- package/src/oxide/cli/build/utils.ts +74 -0
- package/src/oxide/cli/build/watching.ts +225 -0
- package/src/oxide/cli/help/index.ts +69 -0
- package/src/oxide/cli/index.ts +204 -0
- package/src/oxide/cli/init/index.ts +59 -0
- package/src/oxide/cli.ts +1 -0
- package/src/oxide/postcss-plugin.ts +1 -0
- package/src/plugin.js +107 -0
- package/src/postcss-plugins/nesting/README.md +42 -0
- package/src/postcss-plugins/nesting/index.js +13 -0
- package/src/postcss-plugins/nesting/plugin.js +80 -0
- package/src/processTailwindFeatures.js +18 -3
- package/src/public/colors.js +322 -0
- package/src/public/create-plugin.js +2 -0
- package/src/public/default-config.js +4 -0
- package/src/public/default-theme.js +4 -0
- package/src/public/load-config.js +2 -0
- package/src/public/resolve-config.js +7 -0
- package/src/util/applyImportantSelector.js +19 -0
- package/src/util/buildMediaQuery.js +14 -16
- package/src/util/cloneNodes.js +19 -2
- package/src/util/color.js +43 -11
- package/src/util/createUtilityPlugin.js +2 -11
- package/src/util/dataTypes.js +281 -0
- package/src/util/defaults.js +6 -0
- package/src/util/formatVariantSelector.js +412 -0
- package/src/util/getAllConfigs.js +21 -2
- package/src/util/isSyntacticallyValidPropertyValue.js +61 -0
- package/src/util/log.js +23 -22
- package/src/util/nameClass.js +6 -2
- package/src/util/negateValue.js +15 -5
- package/src/util/normalizeConfig.js +318 -0
- package/src/util/normalizeScreens.js +140 -0
- package/src/util/parseAnimationValue.js +7 -1
- package/src/util/parseBoxShadowValue.js +72 -0
- package/src/util/parseDependency.js +37 -38
- package/src/util/parseGlob.js +24 -0
- package/src/util/pluginUtils.js +219 -219
- package/src/util/prefixSelector.js +30 -13
- package/src/util/removeAlphaVariables.js +24 -0
- package/src/util/resolveConfig.js +86 -91
- package/src/util/resolveConfigPath.js +12 -1
- package/src/util/splitAtTopLevelOnly.js +52 -0
- package/src/util/toPath.js +23 -1
- package/src/util/transformThemeValue.js +33 -8
- package/src/util/validateConfig.js +13 -0
- package/src/util/validateFormalSyntax.js +34 -0
- package/src/util/withAlphaVariable.js +14 -9
- package/stubs/.gitignore +1 -0
- package/stubs/.prettierrc.json +6 -0
- package/stubs/{defaultConfig.stub.js → config.full.js} +332 -249
- package/stubs/{simpleConfig.stub.js → config.simple.js} +0 -1
- package/stubs/postcss.config.js +6 -0
- package/stubs/tailwind.config.cjs +2 -0
- package/stubs/tailwind.config.js +2 -0
- package/stubs/tailwind.config.ts +3 -0
- package/types/config.d.ts +373 -0
- package/types/generated/.gitkeep +0 -0
- package/types/generated/colors.d.ts +298 -0
- package/types/generated/corePluginList.d.ts +1 -0
- package/types/generated/default-theme.d.ts +347 -0
- package/types/index.d.ts +7 -0
- package/CHANGELOG.md +0 -1742
- package/lib/constants.js +0 -37
- package/lib/lib/setupWatchingContext.js +0 -331
- package/nesting/plugin.js +0 -41
- package/scripts/install-integrations.js +0 -27
- package/scripts/rebuildFixtures.js +0 -68
- package/src/constants.js +0 -17
- package/src/lib/setupWatchingContext.js +0 -307
- /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
|
|
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 =
|
|
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
|
-
|
|
179
|
+
// Handle at-rules (which contains nested rules)
|
|
180
|
+
else if (node.type === 'atrule') {
|
|
65
181
|
node.walkRules((rule) => {
|
|
66
|
-
|
|
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 (
|
|
80
|
-
|
|
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
|
-
|
|
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
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
221
|
+
export function parseVariant(variant) {
|
|
222
|
+
variant = variant
|
|
223
|
+
.replace(/\n+/g, '')
|
|
224
|
+
.replace(/\s{1,}/g, ' ')
|
|
225
|
+
.trim()
|
|
128
226
|
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
227
|
+
let fns = parseVariantFormatString(variant)
|
|
228
|
+
.map((str) => {
|
|
229
|
+
if (!str.startsWith('@')) {
|
|
230
|
+
return ({ format }) => format(str)
|
|
132
231
|
}
|
|
133
232
|
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
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
|
-
|
|
142
|
-
|
|
143
|
-
|
|
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
|
-
|
|
176
|
-
|
|
177
|
-
|
|
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
|
-
|
|
180
|
-
|
|
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
|
|
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
|
-
|
|
203
|
-
for (let [identifier, rule] of withIdentifiers(
|
|
204
|
-
let
|
|
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(
|
|
207
|
-
context.candidateRuleMap.set(
|
|
302
|
+
if (!context.candidateRuleMap.has(prefixedIdentifier)) {
|
|
303
|
+
context.candidateRuleMap.set(prefixedIdentifier, [])
|
|
208
304
|
}
|
|
209
305
|
|
|
210
|
-
context.candidateRuleMap
|
|
306
|
+
context.candidateRuleMap
|
|
307
|
+
.get(prefixedIdentifier)
|
|
308
|
+
.push([{ sort: offset, layer: 'base' }, rule])
|
|
211
309
|
}
|
|
212
310
|
},
|
|
213
|
-
|
|
214
|
-
|
|
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:
|
|
329
|
+
.push([{ sort: offsets.create('defaults'), layer: 'defaults' }, rule])
|
|
225
330
|
}
|
|
226
331
|
},
|
|
227
332
|
addComponents(components, options) {
|
|
228
333
|
let defaultOptions = {
|
|
229
|
-
|
|
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:
|
|
352
|
+
.push([{ sort: offsets.create('components'), layer: 'components', options }, rule])
|
|
254
353
|
}
|
|
255
354
|
},
|
|
256
355
|
addUtilities(utilities, options) {
|
|
257
356
|
let defaultOptions = {
|
|
258
|
-
|
|
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:
|
|
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
|
-
|
|
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
|
|
305
|
-
|
|
306
|
-
|
|
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 (
|
|
403
|
+
if (value === undefined) {
|
|
309
404
|
return []
|
|
310
405
|
}
|
|
311
406
|
|
|
312
|
-
if (!
|
|
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
|
|
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
|
|
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))
|
|
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
|
-
|
|
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,
|
|
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
|
|
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 = [
|
|
754
|
+
let beforeVariants = [
|
|
755
|
+
variantPlugins['pseudoElementVariants'],
|
|
756
|
+
variantPlugins['pseudoClassVariants'],
|
|
757
|
+
variantPlugins['ariaVariants'],
|
|
758
|
+
variantPlugins['dataVariants'],
|
|
759
|
+
]
|
|
458
760
|
let afterVariants = [
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
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
|
-
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
|
|
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
|
-
|
|
498
|
-
|
|
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) => [
|
|
808
|
+
variantFunctions.map((variantFunction, idx) => [
|
|
809
|
+
offsets.forVariant(variantName, idx),
|
|
810
|
+
variantFunction,
|
|
811
|
+
])
|
|
534
812
|
)
|
|
535
813
|
}
|
|
536
814
|
|
|
537
|
-
|
|
538
|
-
|
|
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
|
-
|
|
821
|
+
context.changedContent.push({ content: value, extension: 'html' })
|
|
549
822
|
continue
|
|
550
823
|
}
|
|
551
824
|
|
|
552
825
|
if (value instanceof RegExp) {
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
573
|
-
|
|
574
|
-
|
|
575
|
-
|
|
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
|
-
|
|
982
|
+
if (utilOptions?.types?.some(({ type }) => type === 'color')) {
|
|
983
|
+
modifiers.push(...Object.keys(context.tailwindConfig.theme.opacity ?? {}))
|
|
984
|
+
}
|
|
590
985
|
|
|
591
|
-
|
|
986
|
+
let metadata = { modifiers }
|
|
987
|
+
let includeMetadata = options.includeMetadata && modifiers.length > 0
|
|
592
988
|
|
|
593
|
-
|
|
594
|
-
|
|
595
|
-
|
|
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
|
-
|
|
602
|
-
|
|
1010
|
+
return output
|
|
1011
|
+
}
|
|
603
1012
|
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
|
|
607
|
-
|
|
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
|
|
1160
|
+
return result
|
|
612
1161
|
}
|
|
613
1162
|
}
|
|
614
1163
|
|
|
615
|
-
|
|
616
|
-
|
|
617
|
-
|
|
618
|
-
|
|
619
|
-
|
|
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
|
-
|
|
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,
|
|
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, [],
|
|
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
|
}
|