tailwindcss 0.0.0-insiders.93e0fdf → 0.0.0-insiders.941ef21

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 (170) hide show
  1. package/CHANGELOG.md +293 -5
  2. package/README.md +13 -9
  3. package/colors.d.ts +3 -0
  4. package/defaultConfig.d.ts +3 -0
  5. package/defaultTheme.d.ts +4 -0
  6. package/lib/cli/build/deps.js +54 -0
  7. package/lib/cli/build/index.js +48 -0
  8. package/lib/cli/build/plugin.js +362 -0
  9. package/lib/cli/build/utils.js +78 -0
  10. package/lib/cli/build/watching.js +178 -0
  11. package/lib/cli/help/index.js +71 -0
  12. package/lib/cli/index.js +18 -0
  13. package/lib/cli/init/index.js +46 -0
  14. package/lib/cli/shared.js +12 -0
  15. package/lib/cli-peer-dependencies.js +20 -7
  16. package/lib/cli.js +109 -611
  17. package/lib/constants.js +27 -20
  18. package/lib/corePluginList.js +6 -3
  19. package/lib/corePlugins.js +2005 -1686
  20. package/lib/css/preflight.css +4 -4
  21. package/lib/featureFlags.js +36 -24
  22. package/lib/index.js +28 -10
  23. package/lib/lib/cacheInvalidation.js +90 -0
  24. package/lib/lib/collapseAdjacentRules.js +28 -10
  25. package/lib/lib/collapseDuplicateDeclarations.js +14 -11
  26. package/lib/lib/content.js +177 -0
  27. package/lib/lib/defaultExtractor.js +225 -33
  28. package/lib/lib/detectNesting.js +13 -10
  29. package/lib/lib/evaluateTailwindFunctions.js +118 -55
  30. package/lib/lib/expandApplyAtRules.js +439 -193
  31. package/lib/lib/expandTailwindAtRules.js +104 -109
  32. package/lib/lib/findAtConfigPath.js +44 -0
  33. package/lib/lib/generateRules.js +405 -197
  34. package/lib/lib/getModuleDependencies.js +11 -8
  35. package/lib/lib/normalizeTailwindDirectives.js +35 -32
  36. package/lib/lib/offsets.js +285 -0
  37. package/lib/lib/partitionApplyAtRules.js +11 -8
  38. package/lib/lib/regex.js +60 -0
  39. package/lib/lib/remap-bitfield.js +87 -0
  40. package/lib/lib/resolveDefaultsAtRules.js +89 -67
  41. package/lib/lib/setupContextUtils.js +617 -309
  42. package/lib/lib/setupTrackingContext.js +38 -67
  43. package/lib/lib/sharedState.js +25 -15
  44. package/lib/lib/substituteScreenAtRules.js +11 -9
  45. package/lib/postcss-plugins/nesting/README.md +2 -2
  46. package/lib/postcss-plugins/nesting/index.js +8 -6
  47. package/lib/postcss-plugins/nesting/plugin.js +48 -14
  48. package/lib/processTailwindFeatures.js +31 -28
  49. package/lib/public/colors.js +247 -245
  50. package/lib/public/create-plugin.js +6 -4
  51. package/lib/public/default-config.js +7 -5
  52. package/lib/public/default-theme.js +7 -5
  53. package/lib/public/resolve-config.js +8 -5
  54. package/lib/util/bigSign.js +4 -1
  55. package/lib/util/buildMediaQuery.js +11 -6
  56. package/lib/util/cloneDeep.js +7 -6
  57. package/lib/util/cloneNodes.js +21 -3
  58. package/lib/util/color.js +53 -54
  59. package/lib/util/configurePlugins.js +5 -2
  60. package/lib/util/createPlugin.js +6 -5
  61. package/lib/util/createUtilityPlugin.js +10 -8
  62. package/lib/util/dataTypes.js +143 -110
  63. package/lib/util/defaults.js +8 -5
  64. package/lib/util/escapeClassName.js +9 -6
  65. package/lib/util/escapeCommas.js +5 -2
  66. package/lib/util/flattenColorPalette.js +9 -10
  67. package/lib/util/formatVariantSelector.js +193 -86
  68. package/lib/util/getAllConfigs.js +29 -10
  69. package/lib/util/hashConfig.js +6 -3
  70. package/lib/util/isKeyframeRule.js +5 -2
  71. package/lib/util/isPlainObject.js +5 -2
  72. package/lib/util/{isValidArbitraryValue.js → isSyntacticallyValidPropertyValue.js} +23 -15
  73. package/lib/util/log.js +20 -14
  74. package/lib/util/nameClass.js +20 -9
  75. package/lib/util/negateValue.js +22 -7
  76. package/lib/util/normalizeConfig.js +124 -83
  77. package/lib/util/normalizeScreens.js +119 -8
  78. package/lib/util/parseAnimationValue.js +42 -40
  79. package/lib/util/parseBoxShadowValue.js +29 -22
  80. package/lib/util/parseDependency.js +38 -56
  81. package/lib/util/parseGlob.js +34 -0
  82. package/lib/util/parseObjectStyles.js +11 -8
  83. package/lib/util/pluginUtils.js +155 -51
  84. package/lib/util/prefixSelector.js +7 -4
  85. package/lib/util/removeAlphaVariables.js +29 -0
  86. package/lib/util/resolveConfig.js +93 -72
  87. package/lib/util/resolveConfigPath.js +10 -7
  88. package/lib/util/responsive.js +8 -5
  89. package/lib/util/splitAtTopLevelOnly.js +43 -0
  90. package/lib/util/tap.js +4 -1
  91. package/lib/util/toColorValue.js +5 -2
  92. package/lib/util/toPath.js +20 -4
  93. package/lib/util/transformThemeValue.js +37 -25
  94. package/lib/util/validateConfig.js +24 -0
  95. package/lib/util/validateFormalSyntax.js +24 -0
  96. package/lib/util/withAlphaVariable.js +23 -15
  97. package/package.json +44 -37
  98. package/peers/index.js +11099 -7475
  99. package/plugin.d.ts +11 -0
  100. package/resolveConfig.d.ts +12 -0
  101. package/scripts/generate-types.js +105 -0
  102. package/scripts/release-channel.js +18 -0
  103. package/scripts/release-notes.js +21 -0
  104. package/scripts/type-utils.js +27 -0
  105. package/src/cli/build/deps.js +56 -0
  106. package/src/cli/build/index.js +49 -0
  107. package/src/cli/build/plugin.js +434 -0
  108. package/src/cli/build/utils.js +76 -0
  109. package/src/cli/build/watching.js +227 -0
  110. package/src/cli/help/index.js +70 -0
  111. package/src/cli/index.js +3 -0
  112. package/src/cli/init/index.js +50 -0
  113. package/src/cli/shared.js +5 -0
  114. package/src/cli-peer-dependencies.js +7 -1
  115. package/src/cli.js +50 -631
  116. package/src/corePluginList.js +1 -1
  117. package/src/corePlugins.js +399 -84
  118. package/src/css/preflight.css +4 -4
  119. package/src/featureFlags.js +14 -4
  120. package/src/index.js +20 -1
  121. package/src/lib/cacheInvalidation.js +52 -0
  122. package/src/lib/collapseAdjacentRules.js +21 -2
  123. package/src/lib/content.js +213 -0
  124. package/src/lib/defaultExtractor.js +196 -35
  125. package/src/lib/evaluateTailwindFunctions.js +78 -7
  126. package/src/lib/expandApplyAtRules.js +482 -183
  127. package/src/lib/expandTailwindAtRules.js +37 -55
  128. package/src/lib/findAtConfigPath.js +48 -0
  129. package/src/lib/generateRules.js +359 -112
  130. package/src/lib/offsets.js +351 -0
  131. package/src/lib/regex.js +74 -0
  132. package/src/lib/remap-bitfield.js +82 -0
  133. package/src/lib/resolveDefaultsAtRules.js +53 -32
  134. package/src/lib/setupContextUtils.js +517 -146
  135. package/src/lib/setupTrackingContext.js +11 -48
  136. package/src/lib/sharedState.js +3 -0
  137. package/src/postcss-plugins/nesting/README.md +2 -2
  138. package/src/postcss-plugins/nesting/plugin.js +36 -0
  139. package/src/util/buildMediaQuery.js +5 -3
  140. package/src/util/cloneNodes.js +19 -2
  141. package/src/util/color.js +25 -21
  142. package/src/util/dataTypes.js +54 -21
  143. package/src/util/formatVariantSelector.js +196 -62
  144. package/src/util/getAllConfigs.js +19 -0
  145. package/src/util/{isValidArbitraryValue.js → isSyntacticallyValidPropertyValue.js} +1 -1
  146. package/src/util/log.js +8 -8
  147. package/src/util/nameClass.js +4 -0
  148. package/src/util/negateValue.js +10 -2
  149. package/src/util/normalizeConfig.js +40 -10
  150. package/src/util/normalizeScreens.js +99 -4
  151. package/src/util/parseBoxShadowValue.js +3 -2
  152. package/src/util/parseDependency.js +37 -42
  153. package/src/util/parseGlob.js +24 -0
  154. package/src/util/pluginUtils.js +132 -10
  155. package/src/util/removeAlphaVariables.js +24 -0
  156. package/src/util/resolveConfig.js +70 -32
  157. package/src/util/splitAtTopLevelOnly.js +45 -0
  158. package/src/util/toPath.js +1 -1
  159. package/src/util/transformThemeValue.js +13 -3
  160. package/src/util/validateConfig.js +13 -0
  161. package/src/util/validateFormalSyntax.js +34 -0
  162. package/src/util/withAlphaVariable.js +1 -1
  163. package/stubs/defaultConfig.stub.js +168 -164
  164. package/stubs/simpleConfig.stub.js +1 -0
  165. package/types/config.d.ts +363 -0
  166. package/types/generated/.gitkeep +0 -0
  167. package/types/generated/colors.d.ts +276 -0
  168. package/types/generated/corePluginList.d.ts +1 -0
  169. package/types/generated/default-theme.d.ts +342 -0
  170. package/types/index.d.ts +7 -0
@@ -2,32 +2,49 @@
2
2
  Object.defineProperty(exports, "__esModule", {
3
3
  value: true
4
4
  });
5
- exports.default = expandApplyAtRules;
6
- var _postcss = _interopRequireDefault(require("postcss"));
7
- var _postcssSelectorParser = _interopRequireDefault(require("postcss-selector-parser"));
8
- var _generateRules = require("./generateRules");
9
- var _bigSign = _interopRequireDefault(require("../util/bigSign"));
10
- var _escapeClassName = _interopRequireDefault(require("../util/escapeClassName"));
5
+ Object.defineProperty(exports, "default", {
6
+ enumerable: true,
7
+ get: ()=>expandApplyAtRules
8
+ });
9
+ const _postcss = /*#__PURE__*/ _interopRequireDefault(require("postcss"));
10
+ const _postcssSelectorParser = /*#__PURE__*/ _interopRequireDefault(require("postcss-selector-parser"));
11
+ const _generateRules = require("./generateRules");
12
+ const _escapeClassName = /*#__PURE__*/ _interopRequireDefault(require("../util/escapeClassName"));
11
13
  function _interopRequireDefault(obj) {
12
14
  return obj && obj.__esModule ? obj : {
13
15
  default: obj
14
16
  };
15
17
  }
16
- function extractClasses(node) {
17
- let classes = new Set();
18
+ /** @typedef {Map<string, [any, import('postcss').Rule[]]>} ApplyCache */ function extractClasses(node) {
19
+ /** @type {Map<string, Set<string>>} */ let groups = new Map();
18
20
  let container = _postcss.default.root({
19
21
  nodes: [
20
22
  node.clone()
21
23
  ]
22
24
  });
23
25
  container.walkRules((rule)=>{
24
- (0, _postcssSelectorParser).default((selectors)=>{
26
+ (0, _postcssSelectorParser.default)((selectors)=>{
25
27
  selectors.walkClasses((classSelector)=>{
28
+ let parentSelector = classSelector.parent.toString();
29
+ let classes = groups.get(parentSelector);
30
+ if (!classes) {
31
+ groups.set(parentSelector, classes = new Set());
32
+ }
26
33
  classes.add(classSelector.value);
27
34
  });
28
35
  }).processSync(rule.selector);
29
36
  });
30
- return Array.from(classes);
37
+ let normalizedGroups = Array.from(groups.values(), (classes)=>Array.from(classes));
38
+ let classes = normalizedGroups.flat();
39
+ return Object.assign(classes, {
40
+ groups: normalizedGroups
41
+ });
42
+ }
43
+ let selectorExtractor = (0, _postcssSelectorParser.default)();
44
+ /**
45
+ * @param {string} ruleSelectors
46
+ */ function extractSelectors(ruleSelectors) {
47
+ return selectorExtractor.astSync(ruleSelectors);
31
48
  }
32
49
  function extractBaseCandidates(candidates, separator) {
33
50
  let baseClasses = new Set();
@@ -37,10 +54,117 @@ function extractBaseCandidates(candidates, separator) {
37
54
  return Array.from(baseClasses);
38
55
  }
39
56
  function prefix(context, selector) {
40
- let prefix1 = context.tailwindConfig.prefix;
41
- return typeof prefix1 === 'function' ? prefix1(selector) : prefix1 + selector;
57
+ let prefix = context.tailwindConfig.prefix;
58
+ return typeof prefix === "function" ? prefix(selector) : prefix + selector;
59
+ }
60
+ function* pathToRoot(node) {
61
+ yield node;
62
+ while(node.parent){
63
+ yield node.parent;
64
+ node = node.parent;
65
+ }
66
+ }
67
+ /**
68
+ * Only clone the node itself and not its children
69
+ *
70
+ * @param {*} node
71
+ * @param {*} overrides
72
+ * @returns
73
+ */ function shallowClone(node, overrides = {}) {
74
+ let children = node.nodes;
75
+ node.nodes = [];
76
+ let tmp = node.clone(overrides);
77
+ node.nodes = children;
78
+ return tmp;
42
79
  }
43
- function buildApplyCache(applyCandidates, context) {
80
+ /**
81
+ * Clone just the nodes all the way to the top that are required to represent
82
+ * this singular rule in the tree.
83
+ *
84
+ * For example, if we have CSS like this:
85
+ * ```css
86
+ * @media (min-width: 768px) {
87
+ * @supports (display: grid) {
88
+ * .foo {
89
+ * display: grid;
90
+ * grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
91
+ * }
92
+ * }
93
+ *
94
+ * @supports (backdrop-filter: blur(1px)) {
95
+ * .bar {
96
+ * backdrop-filter: blur(1px);
97
+ * }
98
+ * }
99
+ *
100
+ * .baz {
101
+ * color: orange;
102
+ * }
103
+ * }
104
+ * ```
105
+ *
106
+ * And we're cloning `.bar` it'll return a cloned version of what's required for just that single node:
107
+ *
108
+ * ```css
109
+ * @media (min-width: 768px) {
110
+ * @supports (backdrop-filter: blur(1px)) {
111
+ * .bar {
112
+ * backdrop-filter: blur(1px);
113
+ * }
114
+ * }
115
+ * }
116
+ * ```
117
+ *
118
+ * @param {import('postcss').Node} node
119
+ */ function nestedClone(node) {
120
+ for (let parent of pathToRoot(node)){
121
+ if (node === parent) {
122
+ continue;
123
+ }
124
+ if (parent.type === "root") {
125
+ break;
126
+ }
127
+ node = shallowClone(parent, {
128
+ nodes: [
129
+ node
130
+ ]
131
+ });
132
+ }
133
+ return node;
134
+ }
135
+ /**
136
+ * @param {import('postcss').Root} root
137
+ */ function buildLocalApplyCache(root, context) {
138
+ /** @type {ApplyCache} */ let cache = new Map();
139
+ root.walkRules((rule)=>{
140
+ // Ignore rules generated by Tailwind
141
+ for (let node of pathToRoot(rule)){
142
+ var _node_raws_tailwind;
143
+ if (((_node_raws_tailwind = node.raws.tailwind) === null || _node_raws_tailwind === void 0 ? void 0 : _node_raws_tailwind.layer) !== undefined) {
144
+ return;
145
+ }
146
+ }
147
+ // Clone what's required to represent this singular rule in the tree
148
+ let container = nestedClone(rule);
149
+ let sort = context.offsets.create("user");
150
+ for (let className of extractClasses(rule)){
151
+ let list = cache.get(className) || [];
152
+ cache.set(className, list);
153
+ list.push([
154
+ {
155
+ layer: "user",
156
+ sort,
157
+ important: false
158
+ },
159
+ container
160
+ ]);
161
+ }
162
+ });
163
+ return cache;
164
+ }
165
+ /**
166
+ * @returns {ApplyCache}
167
+ */ function buildApplyCache(applyCandidates, context) {
44
168
  for (let candidate of applyCandidates){
45
169
  if (context.notClassCache.has(candidate) || context.applyClassCache.has(candidate)) {
46
170
  continue;
@@ -49,11 +173,10 @@ function buildApplyCache(applyCandidates, context) {
49
173
  context.applyClassCache.set(candidate, context.classCache.get(candidate).map(([meta, rule])=>[
50
174
  meta,
51
175
  rule.clone()
52
- ]
53
- ));
176
+ ]));
54
177
  continue;
55
178
  }
56
- let matches = Array.from((0, _generateRules).resolveMatches(candidate, context));
179
+ let matches = Array.from((0, _generateRules.resolveMatches)(candidate, context));
57
180
  if (matches.length === 0) {
58
181
  context.notClassCache.add(candidate);
59
182
  continue;
@@ -62,9 +185,39 @@ function buildApplyCache(applyCandidates, context) {
62
185
  }
63
186
  return context.applyClassCache;
64
187
  }
188
+ /**
189
+ * Build a cache only when it's first used
190
+ *
191
+ * @param {() => ApplyCache} buildCacheFn
192
+ * @returns {ApplyCache}
193
+ */ function lazyCache(buildCacheFn) {
194
+ let cache = null;
195
+ return {
196
+ get: (name)=>{
197
+ cache = cache || buildCacheFn();
198
+ return cache.get(name);
199
+ },
200
+ has: (name)=>{
201
+ cache = cache || buildCacheFn();
202
+ return cache.has(name);
203
+ }
204
+ };
205
+ }
206
+ /**
207
+ * Take a series of multiple caches and merge
208
+ * them so they act like one large cache
209
+ *
210
+ * @param {ApplyCache[]} caches
211
+ * @returns {ApplyCache}
212
+ */ function combineCaches(caches) {
213
+ return {
214
+ get: (name)=>caches.flatMap((cache)=>cache.get(name) || []),
215
+ has: (name)=>caches.some((cache)=>cache.has(name))
216
+ };
217
+ }
65
218
  function extractApplyCandidates(params) {
66
219
  let candidates = params.split(/[\s\t\n]+/g);
67
- if (candidates[candidates.length - 1] === '!important') {
220
+ if (candidates[candidates.length - 1] === "!important") {
68
221
  return [
69
222
  candidates.slice(0, -1),
70
223
  true
@@ -75,11 +228,11 @@ function extractApplyCandidates(params) {
75
228
  false
76
229
  ];
77
230
  }
78
- function processApply(root, context) {
231
+ function processApply(root, context, localCache) {
79
232
  let applyCandidates = new Set();
80
233
  // Collect all @apply rules and candidates
81
234
  let applies = [];
82
- root.walkAtRules('apply', (rule)=>{
235
+ root.walkAtRules("apply", (rule)=>{
83
236
  let [candidates] = extractApplyCandidates(rule.params);
84
237
  for (let util of candidates){
85
238
  applyCandidates.add(util);
@@ -87,194 +240,287 @@ function processApply(root, context) {
87
240
  applies.push(rule);
88
241
  });
89
242
  // Start the @apply process if we have rules with @apply in them
90
- if (applies.length > 0) {
91
- // Fill up some caches!
92
- let applyClassCache = buildApplyCache(applyCandidates, context);
93
- /**
94
- * When we have an apply like this:
95
- *
96
- * .abc {
97
- * @apply hover:font-bold;
98
- * }
99
- *
100
- * What we essentially will do is resolve to this:
101
- *
102
- * .abc {
103
- * @apply .hover\:font-bold:hover {
104
- * font-weight: 500;
105
- * }
106
- * }
107
- *
108
- * Notice that the to-be-applied class is `.hover\:font-bold:hover` and that the utility candidate was `hover:font-bold`.
109
- * What happens in this function is that we prepend a `.` and escape the candidate.
110
- * This will result in `.hover\:font-bold`
111
- * Which means that we can replace `.hover\:font-bold` with `.abc` in `.hover\:font-bold:hover` resulting in `.abc:hover`
112
- */ // TODO: Should we use postcss-selector-parser for this instead?
113
- function replaceSelector(selector, utilitySelectors, candidate) {
114
- let needle = `.${(0, _escapeClassName).default(candidate)}`;
115
- let utilitySelectorsList = utilitySelectors.split(/\s*\,(?![^(]*\))\s*/g);
116
- return selector.split(/\s*\,(?![^(]*\))\s*/g).map((s)=>{
117
- let replaced = [];
118
- for (let utilitySelector of utilitySelectorsList){
119
- let replacedSelector = utilitySelector.replace(needle, s);
120
- if (replacedSelector === utilitySelector) {
121
- continue;
243
+ if (applies.length === 0) {
244
+ return;
245
+ }
246
+ // Fill up some caches!
247
+ let applyClassCache = combineCaches([
248
+ localCache,
249
+ buildApplyCache(applyCandidates, context)
250
+ ]);
251
+ /**
252
+ * When we have an apply like this:
253
+ *
254
+ * .abc {
255
+ * @apply hover:font-bold;
256
+ * }
257
+ *
258
+ * What we essentially will do is resolve to this:
259
+ *
260
+ * .abc {
261
+ * @apply .hover\:font-bold:hover {
262
+ * font-weight: 500;
263
+ * }
264
+ * }
265
+ *
266
+ * Notice that the to-be-applied class is `.hover\:font-bold:hover` and that the utility candidate was `hover:font-bold`.
267
+ * What happens in this function is that we prepend a `.` and escape the candidate.
268
+ * This will result in `.hover\:font-bold`
269
+ * Which means that we can replace `.hover\:font-bold` with `.abc` in `.hover\:font-bold:hover` resulting in `.abc:hover`
270
+ *
271
+ * @param {string} selector
272
+ * @param {string} utilitySelectors
273
+ * @param {string} candidate
274
+ */ function replaceSelector(selector, utilitySelectors, candidate) {
275
+ let selectorList = extractSelectors(selector);
276
+ let utilitySelectorsList = extractSelectors(utilitySelectors);
277
+ let candidateList = extractSelectors(`.${(0, _escapeClassName.default)(candidate)}`);
278
+ let candidateClass = candidateList.nodes[0].nodes[0];
279
+ selectorList.each((sel)=>{
280
+ /** @type {Set<import('postcss-selector-parser').Selector>} */ let replaced = new Set();
281
+ utilitySelectorsList.each((utilitySelector)=>{
282
+ let hasReplaced = false;
283
+ utilitySelector = utilitySelector.clone();
284
+ utilitySelector.walkClasses((node)=>{
285
+ if (node.value !== candidateClass.value) {
286
+ return;
287
+ }
288
+ // Don't replace multiple instances of the same class
289
+ // This is theoretically correct but only partially
290
+ // We'd need to generate every possible permutation of the replacement
291
+ // For example with `.foo + .foo { … }` and `section { @apply foo; }`
292
+ // We'd need to generate all of these:
293
+ // - `.foo + .foo`
294
+ // - `.foo + section`
295
+ // - `section + .foo`
296
+ // - `section + section`
297
+ if (hasReplaced) {
298
+ return;
299
+ }
300
+ // Since you can only `@apply` class names this is sufficient
301
+ // We want to replace the matched class name with the selector the user is using
302
+ // Ex: Replace `.text-blue-500` with `.foo.bar:is(.something-cool)`
303
+ node.replaceWith(...sel.nodes.map((node)=>node.clone()));
304
+ // Record that we did something and we want to use this new selector
305
+ replaced.add(utilitySelector);
306
+ hasReplaced = true;
307
+ });
308
+ });
309
+ // Sort tag names before class names (but only sort each group (separated by a combinator)
310
+ // separately and not in total)
311
+ // This happens when replacing `.bar` in `.foo.bar` with a tag like `section`
312
+ for (let sel1 of replaced){
313
+ let groups = [
314
+ []
315
+ ];
316
+ for (let node of sel1.nodes){
317
+ if (node.type === "combinator") {
318
+ groups.push(node);
319
+ groups.push([]);
320
+ } else {
321
+ let last = groups[groups.length - 1];
322
+ last.push(node);
122
323
  }
123
- replaced.push(replacedSelector);
124
324
  }
125
- return replaced.join(', ');
126
- }).join(', ');
127
- }
128
- let perParentApplies = new Map();
129
- // Collect all apply candidates and their rules
130
- for (let apply of applies){
131
- let candidates = perParentApplies.get(apply.parent) || [];
132
- perParentApplies.set(apply.parent, candidates);
133
- let [applyCandidates, important] = extractApplyCandidates(apply.params);
134
- if (apply.parent.type === 'atrule') {
135
- if (apply.parent.name === 'screen') {
136
- const screenType = apply.parent.params;
137
- throw apply.error(`@apply is not supported within nested at-rules like @screen. We suggest you write this as @apply ${applyCandidates.map((c)=>`${screenType}:${c}`
138
- ).join(' ')} instead.`);
325
+ sel1.nodes = [];
326
+ for (let group of groups){
327
+ if (Array.isArray(group)) {
328
+ group.sort((a, b)=>{
329
+ if (a.type === "tag" && b.type === "class") {
330
+ return -1;
331
+ } else if (a.type === "class" && b.type === "tag") {
332
+ return 1;
333
+ } else if (a.type === "class" && b.type === "pseudo" && b.value.startsWith("::")) {
334
+ return -1;
335
+ } else if (a.type === "pseudo" && a.value.startsWith("::") && b.type === "class") {
336
+ return 1;
337
+ }
338
+ return 0;
339
+ });
340
+ }
341
+ sel1.nodes = sel1.nodes.concat(group);
139
342
  }
140
- throw apply.error(`@apply is not supported within nested at-rules like @${apply.parent.name}. You can fix this by un-nesting @${apply.parent.name}.`);
141
343
  }
142
- for (let applyCandidate of applyCandidates){
143
- if ([
144
- prefix(context, 'group'),
145
- prefix(context, 'peer')
146
- ].includes(applyCandidate)) {
147
- // TODO: Link to specific documentation page with error code.
148
- throw apply.error(`@apply should not be used with the '${applyCandidate}' utility`);
149
- }
150
- if (!applyClassCache.has(applyCandidate)) {
151
- throw apply.error(`The \`${applyCandidate}\` class does not exist. If \`${applyCandidate}\` is a custom class, make sure it is defined within a \`@layer\` directive.`);
152
- }
153
- let rules = applyClassCache.get(applyCandidate);
154
- candidates.push([
155
- applyCandidate,
156
- important,
157
- rules
158
- ]);
344
+ sel.replaceWith(...replaced);
345
+ });
346
+ return selectorList.toString();
347
+ }
348
+ let perParentApplies = new Map();
349
+ // Collect all apply candidates and their rules
350
+ for (let apply of applies){
351
+ let [candidates] = perParentApplies.get(apply.parent) || [
352
+ [],
353
+ apply.source
354
+ ];
355
+ perParentApplies.set(apply.parent, [
356
+ candidates,
357
+ apply.source
358
+ ]);
359
+ let [applyCandidates1, important] = extractApplyCandidates(apply.params);
360
+ if (apply.parent.type === "atrule") {
361
+ if (apply.parent.name === "screen") {
362
+ let screenType = apply.parent.params;
363
+ throw apply.error(`@apply is not supported within nested at-rules like @screen. We suggest you write this as @apply ${applyCandidates1.map((c)=>`${screenType}:${c}`).join(" ")} instead.`);
159
364
  }
365
+ throw apply.error(`@apply is not supported within nested at-rules like @${apply.parent.name}. You can fix this by un-nesting @${apply.parent.name}.`);
160
366
  }
161
- for (const [parent, candidates] of perParentApplies){
162
- let siblings = [];
163
- for (let [applyCandidate, important, rules] of candidates){
164
- for (let [meta, node] of rules){
165
- let parentClasses = extractClasses(parent);
166
- let nodeClasses = extractClasses(node);
167
- // Add base utility classes from the @apply node to the list of
168
- // classes to check whether it intersects and therefore results in a
169
- // circular dependency or not.
170
- //
171
- // E.g.:
172
- // .foo {
173
- // @apply hover:a; // This applies "a" but with a modifier
174
- // }
175
- //
176
- // We only have to do that with base classes of the `node`, not of the `parent`
177
- // E.g.:
178
- // .hover\:foo {
179
- // @apply bar;
180
- // }
181
- // .bar {
182
- // @apply foo;
183
- // }
184
- //
185
- // This should not result in a circular dependency because we are
186
- // just applying `.foo` and the rule above is `.hover\:foo` which is
187
- // unrelated. However, if we were to apply `hover:foo` then we _did_
188
- // have to include this one.
189
- nodeClasses = nodeClasses.concat(extractBaseCandidates(nodeClasses, context.tailwindConfig.separator));
190
- let intersects = parentClasses.some((selector)=>nodeClasses.includes(selector)
191
- );
192
- if (intersects) {
193
- throw node.error(`You cannot \`@apply\` the \`${applyCandidate}\` utility here because it creates a circular dependency.`);
194
- }
195
- let root = _postcss.default.root({
196
- nodes: [
197
- node.clone()
198
- ]
199
- });
200
- let canRewriteSelector = node.type !== 'atrule' || node.type === 'atrule' && node.name !== 'keyframes';
201
- if (canRewriteSelector) {
202
- root.walkRules((rule)=>{
203
- // Let's imagine you have the following structure:
204
- //
205
- // .foo {
206
- // @apply bar;
207
- // }
208
- //
209
- // @supports (a: b) {
210
- // .bar {
211
- // color: blue
212
- // }
213
- //
214
- // .something-unrelated {}
215
- // }
216
- //
217
- // In this case we want to apply `.bar` but it happens to be in
218
- // an atrule node. We clone that node instead of the nested one
219
- // because we still want that @supports rule to be there once we
220
- // applied everything.
221
- //
222
- // However it happens to be that the `.something-unrelated` is
223
- // also in that same shared @supports atrule. This is not good,
224
- // and this should not be there. The good part is that this is
225
- // a clone already and it can be safely removed. The question is
226
- // how do we know we can remove it. Basically what we can do is
227
- // match it against the applyCandidate that you want to apply. If
228
- // it doesn't match the we can safely delete it.
229
- //
230
- // If we didn't do this, then the `replaceSelector` function
231
- // would have replaced this with something that didn't exist and
232
- // therefore it removed the selector altogether. In this specific
233
- // case it would result in `{}` instead of `.something-unrelated {}`
234
- if (!extractClasses(rule).some((candidate)=>candidate === applyCandidate
235
- )) {
236
- rule.remove();
237
- return;
238
- }
239
- rule.selector = replaceSelector(parent.selector, rule.selector, applyCandidate);
240
- rule.walkDecls((d)=>{
241
- d.important = meta.important || important;
242
- });
367
+ for (let applyCandidate of applyCandidates1){
368
+ if ([
369
+ prefix(context, "group"),
370
+ prefix(context, "peer")
371
+ ].includes(applyCandidate)) {
372
+ // TODO: Link to specific documentation page with error code.
373
+ throw apply.error(`@apply should not be used with the '${applyCandidate}' utility`);
374
+ }
375
+ if (!applyClassCache.has(applyCandidate)) {
376
+ throw apply.error(`The \`${applyCandidate}\` class does not exist. If \`${applyCandidate}\` is a custom class, make sure it is defined within a \`@layer\` directive.`);
377
+ }
378
+ let rules = applyClassCache.get(applyCandidate);
379
+ candidates.push([
380
+ applyCandidate,
381
+ important,
382
+ rules
383
+ ]);
384
+ }
385
+ }
386
+ for (let [parent, [candidates1, atApplySource]] of perParentApplies){
387
+ let siblings = [];
388
+ for (let [applyCandidate1, important1, rules1] of candidates1){
389
+ let potentialApplyCandidates = [
390
+ applyCandidate1,
391
+ ...extractBaseCandidates([
392
+ applyCandidate1
393
+ ], context.tailwindConfig.separator)
394
+ ];
395
+ for (let [meta, node] of rules1){
396
+ let parentClasses = extractClasses(parent);
397
+ let nodeClasses = extractClasses(node);
398
+ // When we encounter a rule like `.dark .a, .b { … }` we only want to be left with `[.dark, .a]` if the base applyCandidate is `.a` or with `[.b]` if the base applyCandidate is `.b`
399
+ // So we've split them into groups
400
+ nodeClasses = nodeClasses.groups.filter((classList)=>classList.some((className)=>potentialApplyCandidates.includes(className))).flat();
401
+ // Add base utility classes from the @apply node to the list of
402
+ // classes to check whether it intersects and therefore results in a
403
+ // circular dependency or not.
404
+ //
405
+ // E.g.:
406
+ // .foo {
407
+ // @apply hover:a; // This applies "a" but with a modifier
408
+ // }
409
+ //
410
+ // We only have to do that with base classes of the `node`, not of the `parent`
411
+ // E.g.:
412
+ // .hover\:foo {
413
+ // @apply bar;
414
+ // }
415
+ // .bar {
416
+ // @apply foo;
417
+ // }
418
+ //
419
+ // This should not result in a circular dependency because we are
420
+ // just applying `.foo` and the rule above is `.hover\:foo` which is
421
+ // unrelated. However, if we were to apply `hover:foo` then we _did_
422
+ // have to include this one.
423
+ nodeClasses = nodeClasses.concat(extractBaseCandidates(nodeClasses, context.tailwindConfig.separator));
424
+ let intersects = parentClasses.some((selector)=>nodeClasses.includes(selector));
425
+ if (intersects) {
426
+ throw node.error(`You cannot \`@apply\` the \`${applyCandidate1}\` utility here because it creates a circular dependency.`);
427
+ }
428
+ let root1 = _postcss.default.root({
429
+ nodes: [
430
+ node.clone()
431
+ ]
432
+ });
433
+ // Make sure every node in the entire tree points back at the @apply rule that generated it
434
+ root1.walk((node)=>{
435
+ node.source = atApplySource;
436
+ });
437
+ let canRewriteSelector = node.type !== "atrule" || node.type === "atrule" && node.name !== "keyframes";
438
+ if (canRewriteSelector) {
439
+ root1.walkRules((rule)=>{
440
+ // Let's imagine you have the following structure:
441
+ //
442
+ // .foo {
443
+ // @apply bar;
444
+ // }
445
+ //
446
+ // @supports (a: b) {
447
+ // .bar {
448
+ // color: blue
449
+ // }
450
+ //
451
+ // .something-unrelated {}
452
+ // }
453
+ //
454
+ // In this case we want to apply `.bar` but it happens to be in
455
+ // an atrule node. We clone that node instead of the nested one
456
+ // because we still want that @supports rule to be there once we
457
+ // applied everything.
458
+ //
459
+ // However it happens to be that the `.something-unrelated` is
460
+ // also in that same shared @supports atrule. This is not good,
461
+ // and this should not be there. The good part is that this is
462
+ // a clone already and it can be safely removed. The question is
463
+ // how do we know we can remove it. Basically what we can do is
464
+ // match it against the applyCandidate that you want to apply. If
465
+ // it doesn't match the we can safely delete it.
466
+ //
467
+ // If we didn't do this, then the `replaceSelector` function
468
+ // would have replaced this with something that didn't exist and
469
+ // therefore it removed the selector altogether. In this specific
470
+ // case it would result in `{}` instead of `.something-unrelated {}`
471
+ if (!extractClasses(rule).some((candidate)=>candidate === applyCandidate1)) {
472
+ rule.remove();
473
+ return;
474
+ }
475
+ // Strip the important selector from the parent selector if at the beginning
476
+ let importantSelector = typeof context.tailwindConfig.important === "string" ? context.tailwindConfig.important : null;
477
+ // We only want to move the "important" selector if this is a Tailwind-generated utility
478
+ // We do *not* want to do this for user CSS that happens to be structured the same
479
+ let isGenerated = parent.raws.tailwind !== undefined;
480
+ let parentSelector = isGenerated && importantSelector && parent.selector.indexOf(importantSelector) === 0 ? parent.selector.slice(importantSelector.length) : parent.selector;
481
+ rule.selector = replaceSelector(parentSelector, rule.selector, applyCandidate1);
482
+ // And then re-add it if it was removed
483
+ if (importantSelector && parentSelector !== parent.selector) {
484
+ rule.selector = `${importantSelector} ${rule.selector}`;
485
+ }
486
+ rule.walkDecls((d)=>{
487
+ d.important = meta.important || important1;
243
488
  });
244
- }
245
- // Insert it
246
- siblings.push([
247
- // Ensure that when we are sorting, that we take the layer order into account
248
- {
249
- ...meta,
250
- sort: meta.sort | context.layerOrder[meta.layer]
251
- },
252
- root.nodes[0],
253
- ]);
489
+ });
490
+ }
491
+ // It could be that the node we were inserted was removed because the class didn't match
492
+ // If that was the *only* rule in the parent, then we have nothing add so we skip it
493
+ if (!root1.nodes[0]) {
494
+ continue;
254
495
  }
496
+ // Insert it
497
+ siblings.push([
498
+ meta.sort,
499
+ root1.nodes[0]
500
+ ]);
255
501
  }
256
- // Inject the rules, sorted, correctly
257
- let nodes = siblings.sort(([a], [z])=>(0, _bigSign).default(a.sort - z.sort)
258
- ).map((s)=>s[1]
259
- );
260
- // `parent` refers to the node at `.abc` in: .abc { @apply mt-2 }
261
- parent.after(nodes);
262
502
  }
263
- for (let apply1 of applies){
264
- // If there are left-over declarations, just remove the @apply
265
- if (apply1.parent.nodes.length > 1) {
266
- apply1.remove();
267
- } else {
268
- // The node is empty, drop the full node
269
- apply1.parent.remove();
270
- }
503
+ // Inject the rules, sorted, correctly
504
+ let nodes = context.offsets.sort(siblings).map((s)=>s[1]);
505
+ // `parent` refers to the node at `.abc` in: .abc { @apply mt-2 }
506
+ parent.after(nodes);
507
+ }
508
+ for (let apply1 of applies){
509
+ // If there are left-over declarations, just remove the @apply
510
+ if (apply1.parent.nodes.length > 1) {
511
+ apply1.remove();
512
+ } else {
513
+ // The node is empty, drop the full node
514
+ apply1.parent.remove();
271
515
  }
272
- // Do it again, in case we have other `@apply` rules
273
- processApply(root, context);
274
516
  }
517
+ // Do it again, in case we have other `@apply` rules
518
+ processApply(root, context, localCache);
275
519
  }
276
520
  function expandApplyAtRules(context) {
277
521
  return (root)=>{
278
- processApply(root, context);
522
+ // Build a cache of the user's CSS so we can use it to resolve classes used by @apply
523
+ let localCache = lazyCache(()=>buildLocalApplyCache(root, context));
524
+ processApply(root, context, localCache);
279
525
  };
280
526
  }