tailwindcss 3.0.24 → 3.1.0

package/lib/lib/generateRules.js

@@ -14,36 +14,56 @@ var sharedState = _interopRequireWildcard(require("./sharedState"));
 var _formatVariantSelector = require("../util/formatVariantSelector");
 var _nameClass = require("../util/nameClass");
 var _dataTypes = require("../util/dataTypes");
+var _setupContextUtils = require("./setupContextUtils");
 var _isValidArbitraryValue = _interopRequireDefault(require("../util/isValidArbitraryValue"));
+var _splitAtTopLevelOnlyJs = require("../util/splitAtTopLevelOnly.js");
+var _featureFlags = require("../featureFlags");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
+function _getRequireWildcardCache() {
+    if (typeof WeakMap !== "function") return null;
+    var cache = new WeakMap();
+    _getRequireWildcardCache = function() {
+        return cache;
+    };
+    return cache;
+}
 function _interopRequireWildcard(obj) {
     if (obj && obj.__esModule) {
         return obj;
-    } else {
-        var newObj = {};
-        if (obj != null) {
-            for(var key in obj){
-                if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                    var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
-                    if (desc.get || desc.set) {
-                        Object.defineProperty(newObj, key, desc);
-                    } else {
-                        newObj[key] = obj[key];
-                    }
-                }
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache();
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
             }
         }
-        newObj.default = obj;
-        return newObj;
     }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
 }
 let classNameParser = (0, _postcssSelectorParser).default((selectors)=>{
-    return selectors.first.filter(({ type  })=>type === "class"
-    ).pop().value;
+    return selectors.first.filter(({ type  })=>type === "class").pop().value;
 });
 function getClassNameFromSelector(selector) {
     return classNameParser.transformSync(selector);
@@ -126,8 +146,7 @@ function applyImportant(matches, classCandidate) {
                 }
                 return className;
             });
-            r.walkDecls((d)=>d.important = true
-            );
+            r.walkDecls((d)=>d.important = true);
         });
         result.push([
             {
@@ -151,8 +170,30 @@ function applyVariant(variant, matches, context) {
     if (matches.length === 0) {
         return matches;
     }
+    let args;
+    // Find partial arbitrary variants
+    if (variant.endsWith("]") && !variant.startsWith("[")) {
+        args = variant.slice(variant.lastIndexOf("[") + 1, -1);
+        variant = variant.slice(0, variant.indexOf(args) - 1 /* - */  - 1 /* [ */ );
+    }
+    // Register arbitrary variants
+    if (isArbitraryValue(variant) && !context.variantMap.has(variant)) {
+        let selector = (0, _dataTypes).normalize(variant.slice(1, -1));
+        if (!(0, _setupContextUtils).isValidVariantFormatString(selector)) {
+            return [];
+        }
+        let fn = (0, _setupContextUtils).parseVariant(selector);
+        let sort = Array.from(context.variantOrder.values()).pop() << 1n;
+        context.variantMap.set(variant, [
+            [
+                sort,
+                fn
+            ]
+        ]);
+        context.variantOrder.set(variant, sort);
+    }
     if (context.variantMap.has(variant)) {
-        let variantFunctionTuples = context.variantMap.get(variant);
+        let variantFunctionTuples = context.variantMap.get(variant).slice();
         let result = [];
         for (let [meta, rule1] of matches){
             // Don't generate variants for user css
@@ -170,8 +211,7 @@ function applyVariant(variant, matches, context) {
                 let originals = new Map();
                 function prepareBackup() {
                     if (originals.size > 0) return; // Already prepared, chicken out
-                    clone.walkRules((rule)=>originals.set(rule, rule.selector)
-                    );
+                    clone.walkRules((rule)=>originals.set(rule, rule.selector));
                 }
                 function modifySelectors(modifierFunction) {
                     prepareBackup();
@@ -207,8 +247,28 @@ function applyVariant(variant, matches, context) {
                     },
                     format (selectorFormat) {
                         collectedFormats.push(selectorFormat);
-                    }
+                    },
+                    args
                 });
+                // It can happen that a list of format strings is returned from within the function. In that
+                // case, we have to process them as well. We can use the existing `variantSort`.
+                if (Array.isArray(ruleWithVariant)) {
+                    for (let [idx, variantFunction] of ruleWithVariant.entries()){
+                        // This is a little bit scary since we are pushing to an array of items that we are
+                        // currently looping over. However, you can also think of it like a processing queue
+                        // where you keep handling jobs until everything is done and each job can queue more
+                        // jobs if needed.
+                        variantFunctionTuples.push([
+                            // TODO: This could have potential bugs if we shift the sort order from variant A far
+                            // enough into the sort space of variant B. The chances are low, but if this happens
+                            // then this might be the place too look at. One potential solution to this problem is
+                            // reserving additional X places for these 'unknown' variants in between.
+                            variantSort | BigInt(idx << ruleWithVariant.length),
+                            variantFunction, 
+                        ]);
+                    }
+                    continue;
+                }
                 if (typeof ruleWithVariant === "string") {
                     collectedFormats.push(ruleWithVariant);
                 }
@@ -366,8 +426,7 @@ function extractArbitraryProperty(classCandidate, context) {
                     [(0, _nameClass).asClass(classCandidate)]: {
                         [property]: normalized
                     }
-                })
-            , 
+                }), 
         ], 
     ];
 }
@@ -390,7 +449,8 @@ function* resolveMatchedPlugins(classCandidate, context) {
     let negative = false;
     const twConfigPrefix = context.tailwindConfig.prefix;
     const twConfigPrefixLen = twConfigPrefix.length;
-    if (candidatePrefix[twConfigPrefixLen] === "-") {
+    const hasMatchingPrefix = candidatePrefix.startsWith(twConfigPrefix) || candidatePrefix.startsWith(`-${twConfigPrefix}`);
+    if (candidatePrefix[twConfigPrefixLen] === "-" && hasMatchingPrefix) {
         negative = true;
         candidatePrefix = twConfigPrefix + candidatePrefix.slice(twConfigPrefixLen + 1);
     }
@@ -415,7 +475,7 @@ function splitWithSeparator(input, separator) {
             sharedState.NOT_ON_DEMAND
         ];
     }
-    return input.split(new RegExp(`\\${separator}(?![^[]*\\])`, "g"));
+    return Array.from((0, _splitAtTopLevelOnlyJs).splitAtTopLevelOnly(input, separator));
 }
 function* recordCandidates(matches, classCandidate) {
     for (const match of matches){
@@ -426,7 +486,7 @@ function* recordCandidates(matches, classCandidate) {
         yield match;
     }
 }
-function* resolveMatches(candidate, context) {
+function* resolveMatches(candidate, context, original = candidate) {
     let separator = context.tailwindConfig.separator;
     let [classCandidate, ...variants] = splitWithSeparator(candidate, separator).reverse();
     let important = false;
@@ -434,6 +494,14 @@ function* resolveMatches(candidate, context) {
         important = true;
         classCandidate = classCandidate.slice(1);
     }
+    if ((0, _featureFlags).flagEnabled(context.tailwindConfig, "variantGrouping")) {
+        if (classCandidate.startsWith("(") && classCandidate.endsWith(")")) {
+            let base = variants.slice().reverse().join(separator);
+            for (let part of (0, _splitAtTopLevelOnlyJs).splitAtTopLevelOnly(classCandidate.slice(1, -1), ",")){
+                yield* resolveMatches(base + separator + part, context, original);
+            }
+        }
+    }
     // TODO: Reintroduce this in ways that doesn't break on false positives
     // function sortAgainst(toSort, against) {
     //   return toSort.slice().sort((a, z) => {
@@ -499,8 +567,7 @@ function* resolveMatches(candidate, context) {
                 var ref1;
                 let typesPerPlugin = matches.map((match)=>new Set([
                         ...(ref1 = typesByMatches.get(match)) !== null && ref1 !== void 0 ? ref1 : []
-                    ])
-                );
+                    ]));
                 // Remove duplicates, so that we can detect proper unique types for each plugin.
                 for (let pluginTypes of typesPerPlugin){
                     for (let type of pluginTypes){
@@ -518,13 +585,9 @@ function* resolveMatches(candidate, context) {
                 let messages = [];
                 for (let [idx, group] of typesPerPlugin.entries()){
                     for (let type of group){
-                        let rules = matches[idx].map(([, rule])=>rule
-                        ).flat().map((rule)=>rule.toString().split("\n").slice(1, -1) // Remove selector and closing '}'
-                            .map((line)=>line.trim()
-                            ).map((x)=>`      ${x}`
-                            ) // Re-indent
-                            .join("\n")
-                        ).join("\n\n");
+                        let rules = matches[idx].map(([, rule])=>rule).flat().map((rule)=>rule.toString().split("\n").slice(1, -1) // Remove selector and closing '}'
+                            .map((line)=>line.trim()).map((x)=>`      ${x}`) // Re-indent
+                            .join("\n")).join("\n\n");
                         messages.push(`  Use \`${candidate.replace("[", `[${type}:`)}\` for \`${rules.trim()}\``);
                         break;
                     }
@@ -536,9 +599,7 @@ function* resolveMatches(candidate, context) {
                 ]);
                 continue;
             }
-            matches = matches.map((list)=>list.filter((match)=>isParsableNode(match[1])
-                )
-            );
+            matches = matches.map((list)=>list.filter((match)=>isParsableNode(match[1])));
         }
         matches = matches.flat();
         matches = Array.from(recordCandidates(matches, classCandidate));
@@ -563,10 +624,13 @@ function* resolveMatches(candidate, context) {
                     ]
                 });
                 container.walkRules((rule)=>{
+                    var ref;
                     if (inKeyframes(rule)) return;
+                    var ref2;
                     rule.selector = (0, _formatVariantSelector).finalizeSelector(finalFormat, {
                         selector: rule.selector,
-                        candidate,
+                        candidate: original,
+                        base: candidate.split(new RegExp(`\\${(ref2 = context === null || context === void 0 ? void 0 : (ref = context.tailwindConfig) === null || ref === void 0 ? void 0 : ref.separator) !== null && ref2 !== void 0 ? ref2 : ":"}(?![^[]*\\])`)).pop(),
                         context
                     });
                 });
@@ -576,7 +640,6 @@ function* resolveMatches(candidate, context) {
         }
     }
 }
-exports.resolveMatches = resolveMatches;
 function inKeyframes(rule) {
     return rule.parent && rule.parent.type === "atrule" && rule.parent.name === "keyframes";
 }
@@ -640,7 +703,8 @@ function generateRules(candidates, context) {
         ];
     });
 }
-exports.generateRules = generateRules;
 function isArbitraryValue(input) {
     return input.startsWith("[") && input.endsWith("]");
 }
+exports.resolveMatches = resolveMatches;
+exports.generateRules = generateRules;

package/lib/lib/regex.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.pattern = pattern;
+exports.withoutCapturing = withoutCapturing;
+exports.any = any;
+exports.optional = optional;
+exports.zeroOrMore = zeroOrMore;
+exports.nestedBrackets = nestedBrackets;
+exports.escape = escape;
+const REGEX_SPECIAL = /[\\^$.*+?()[\]{}|]/g;
+const REGEX_HAS_SPECIAL = RegExp(REGEX_SPECIAL.source);
+/**
+ * @param {string|RegExp|Array<string|RegExp>} source
+ */ function toSource(source) {
+    source = Array.isArray(source) ? source : [
+        source
+    ];
+    source = source.map((item)=>item instanceof RegExp ? item.source : item);
+    return source.join("");
+}
+function pattern(source) {
+    return new RegExp(toSource(source), "g");
+}
+function withoutCapturing(source) {
+    return new RegExp(`(?:${toSource(source)})`, "g");
+}
+function any(sources) {
+    return `(?:${sources.map(toSource).join("|")})`;
+}
+function optional(source) {
+    return `(?:${toSource(source)})?`;
+}
+function zeroOrMore(source) {
+    return `(?:${toSource(source)})*`;
+}
+function nestedBrackets(open, close, depth = 1) {
+    return withoutCapturing([
+        escape(open),
+        /[^\s]*/,
+        depth === 1 ? `[^${escape(open)}${escape(close)}\s]*` : any([
+            `[^${escape(open)}${escape(close)}\s]*`,
+            nestedBrackets(open, close, depth - 1)
+        ]),
+        /[^\s]*/,
+        escape(close), 
+    ]);
+}
+function escape(string) {
+    return string && REGEX_HAS_SPECIAL.test(string) ? string.replace(REGEX_SPECIAL, "\\$&") : string || "";
+}

package/lib/lib/resolveDefaultsAtRules.js

@@ -52,8 +52,7 @@ function resolveDefaultsAtRules({ tailwindConfig  }) {
                     universalRule.selectors = [
                         ...selectors
                     ];
-                    universalRule.append(universal.nodes.map((node)=>node.clone()
-                    ));
+                    universalRule.append(universal.nodes.map((node)=>node.clone()));
                     universal.before(universalRule);
                 }
             } else {
@@ -63,7 +62,8 @@ function resolveDefaultsAtRules({ tailwindConfig  }) {
                 universalRule.selectors = [
                     "*",
                     "::before",
-                    "::after"
+                    "::after",
+                    "::backdrop"
                 ];
                 universalRule.append(universal.nodes);
                 universal.before(universalRule);
@@ -109,14 +109,12 @@ function minimumImpactSelector(nodes) {
         "id",
         "attribute"
     ]);
-    let splitPointIdx = rest.findIndex((n)=>searchFor.has(n.type)
-    );
+    let splitPointIdx = rest.findIndex((n)=>searchFor.has(n.type));
     if (splitPointIdx === -1) return rest.reverse().join("").trim();
     let node1 = rest[splitPointIdx];
     let bestNode = getNode[node1.type] ? getNode[node1.type](node1) : node1;
     rest = rest.slice(0, splitPointIdx);
-    let combinatorIdx = rest.findIndex((n)=>n.type === "combinator" && n.value === ">"
-    );
+    let combinatorIdx = rest.findIndex((n)=>n.type === "combinator" && n.value === ">");
     if (combinatorIdx !== -1) {
         rest.splice(0, combinatorIdx);
         rest.unshift(_postcssSelectorParser.default.universal());
@@ -128,8 +126,7 @@ function minimumImpactSelector(nodes) {
 }
 let elementSelectorParser = (0, _postcssSelectorParser).default((selectors)=>{
     return selectors.map((s)=>{
-        let nodes = s.split((n)=>n.type === "combinator" && n.value === " "
-        ).pop();
+        let nodes = s.split((n)=>n.type === "combinator" && n.value === " ").pop();
         return minimumImpactSelector(nodes);
     });
 });