tailwindcss 0.0.0-insiders.d3e754a → 0.0.0-insiders.d3f2221

package/lib/lib/expandTailwindAtRules.js

@@ -2,52 +2,81 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = expandTailwindAtRules;
-var _quickLru = _interopRequireDefault(require("quick-lru"));
-var sharedState = _interopRequireWildcard(require("./sharedState"));
-var _generateRules = require("./generateRules");
-var _bigSign = _interopRequireDefault(require("../util/bigSign"));
-var _log = _interopRequireDefault(require("../util/log"));
-var _cloneNodes = _interopRequireDefault(require("../util/cloneNodes"));
-var _defaultExtractor = require("./defaultExtractor");
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return expandTailwindAtRules;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _quicklru = /*#__PURE__*/ _interop_require_default(require("@alloc/quick-lru"));
+const _oxide = require("@tailwindcss/oxide");
+const _sharedState = /*#__PURE__*/ _interop_require_wildcard(require("./sharedState"));
+const _generateRules = require("./generateRules");
+const _log = /*#__PURE__*/ _interop_require_default(require("../util/log"));
+const _cloneNodes = /*#__PURE__*/ _interop_require_default(require("../util/cloneNodes"));
+const _defaultExtractor = require("./defaultExtractor");
+const _featureFlags = require("../featureFlags");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function _interopRequireWildcard(obj) {
-    if (obj && obj.__esModule) {
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && 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(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && 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 env = sharedState.env;
+let env = _sharedState.env;
 const builtInExtractors = {
     DEFAULT: _defaultExtractor.defaultExtractor
 };
 const builtInTransformers = {
-    DEFAULT: (content)=>content
-    ,
+    DEFAULT: (content)=>content,
     svelte: (content)=>content.replace(/(?:^|\s)class:/g, ' ')
 };
-function getExtractor(tailwindConfig, fileExtension) {
-    let extractors = tailwindConfig.content.extract;
-    return extractors[fileExtension] || extractors.DEFAULT || builtInExtractors[fileExtension] || builtInExtractors.DEFAULT;
+function getExtractor(context, fileExtension) {
+    let extractors = context.tailwindConfig.content.extract;
+    return extractors[fileExtension] || extractors.DEFAULT || builtInExtractors[fileExtension] || // Because we call `DEFAULT(context)`, the returning function is always a new function without a
+    // stable identity. Marking it with `DEFAULT_EXTRACTOR` allows us to check if it is the default
+    // extractor without relying on the function identity.
+    Object.assign(builtInExtractors.DEFAULT(context), {
+        DEFAULT_EXTRACTOR: true
+    });
 }
 function getTransformer(tailwindConfig, fileExtension) {
     let transformers = tailwindConfig.content.transform;
@@ -59,7 +88,7 @@ let extractorCache = new WeakMap();
 // up these regexes by 50% that could cut initial build time by like 20%.
 function getClassCandidates(content, extractor, candidates, seen) {
     if (!extractorCache.has(extractor)) {
-        extractorCache.set(extractor, new _quickLru.default({
+        extractorCache.set(extractor, new _quicklru.default({
             maxSize: 25000
         }));
     }
@@ -74,8 +103,7 @@ function getClassCandidates(content, extractor, candidates, seen) {
                 candidates.add(match);
             }
         } else {
-            let extractorMatches = extractor(line).filter((s)=>s !== '!*'
-            );
+            let extractorMatches = extractor(line).filter((s)=>s !== '!*');
             let lineMatchesSet = new Set(extractorMatches);
             for (let match of lineMatchesSet){
                 candidates.add(match);
@@ -84,55 +112,26 @@ function getClassCandidates(content, extractor, candidates, seen) {
         }
     }
 }
-function buildStylesheet(rules, context) {
-    let sortedRules = rules.sort(([a], [z])=>(0, _bigSign).default(a - z)
-    );
+/**
+ *
+ * @param {[import('./offsets.js').RuleOffset, import('postcss').Node][]} rules
+ * @param {*} context
+ */ function buildStylesheet(rules, context) {
+    let sortedRules = context.offsets.sort(rules);
     let returnValue = {
         base: new Set(),
         defaults: new Set(),
         components: new Set(),
         utilities: new Set(),
-        variants: new Set(),
-        // All the CSS that is not Tailwind related can be put in this bucket. This
-        // will make it easier to later use this information when we want to
-        // `@apply` for example. The main reason we do this here is because we
-        // still need to make sure the order is correct. Last but not least, we
-        // will make sure to always re-inject this section into the css, even if
-        // certain rules were not used. This means that it will look like a no-op
-        // from the user's perspective, but we gathered all the useful information
-        // we need.
-        user: new Set()
+        variants: new Set()
     };
     for (let [sort, rule] of sortedRules){
-        if (sort >= context.minimumScreen) {
-            returnValue.variants.add(rule);
-            continue;
-        }
-        if (sort & context.layerOrder.base) {
-            returnValue.base.add(rule);
-            continue;
-        }
-        if (sort & context.layerOrder.defaults) {
-            returnValue.defaults.add(rule);
-            continue;
-        }
-        if (sort & context.layerOrder.components) {
-            returnValue.components.add(rule);
-            continue;
-        }
-        if (sort & context.layerOrder.utilities) {
-            returnValue.utilities.add(rule);
-            continue;
-        }
-        if (sort & context.layerOrder.user) {
-            returnValue.user.add(rule);
-            continue;
-        }
+        returnValue[sort.layer].add(rule);
     }
     return returnValue;
 }
 function expandTailwindAtRules(context) {
-    return (root)=>{
+    return async (root)=>{
         let layerNodes = {
             base: null,
             components: null,
@@ -150,45 +149,88 @@ function expandTailwindAtRules(context) {
                 }
             }
         });
-        if (Object.values(layerNodes).every((n)=>n === null
-        )) {
+        if (Object.values(layerNodes).every((n)=>n === null)) {
             return root;
         }
+        var _context_candidates;
         // ---
         // Find potential rules in changed files
         let candidates = new Set([
-            sharedState.NOT_ON_DEMAND
+            ...(_context_candidates = context.candidates) !== null && _context_candidates !== void 0 ? _context_candidates : [],
+            _sharedState.NOT_ON_DEMAND
         ]);
         let seen = new Set();
         env.DEBUG && console.time('Reading changed files');
-        for (let { content , extension  } of context.changedContent){
-            let transformer = getTransformer(context.tailwindConfig, extension);
-            let extractor = getExtractor(context.tailwindConfig, extension);
-            getClassCandidates(transformer(content), extractor, candidates, seen);
+        if ((0, _featureFlags.flagEnabled)(context.tailwindConfig, 'oxideParser')) {
+            let rustParserContent = [];
+            let regexParserContent = [];
+            for (let item of context.changedContent){
+                var _extractor;
+                let transformer = getTransformer(context.tailwindConfig, item.extension);
+                let extractor = getExtractor(context, item.extension);
+                if (transformer === builtInTransformers.DEFAULT && ((_extractor = extractor) === null || _extractor === void 0 ? void 0 : _extractor.DEFAULT_EXTRACTOR) === true) {
+                    rustParserContent.push(item);
+                } else {
+                    regexParserContent.push([
+                        item,
+                        {
+                            transformer,
+                            extractor
+                        }
+                    ]);
+                }
+            }
+            if (rustParserContent.length > 0) {
+                for (let candidate of (0, _oxide.parseCandidateStrings)(rustParserContent, _oxide.IO.Parallel | _oxide.Parsing.Parallel)){
+                    candidates.add(candidate);
+                }
+            }
+            if (regexParserContent.length > 0) {
+                await Promise.all(regexParserContent.map(async ([{ file, content }, { transformer, extractor }])=>{
+                    content = file ? await _fs.default.promises.readFile(file, 'utf8') : content;
+                    getClassCandidates(transformer(content), extractor, candidates, seen);
+                }));
+            }
+        } else {
+            await Promise.all(context.changedContent.map(async ({ file, content, extension })=>{
+                let transformer = getTransformer(context.tailwindConfig, extension);
+                let extractor = getExtractor(context, extension);
+                content = file ? await _fs.default.promises.readFile(file, 'utf8') : content;
+                getClassCandidates(transformer(content), extractor, candidates, seen);
+            }));
         }
         env.DEBUG && console.timeEnd('Reading changed files');
         // ---
         // Generate the actual CSS
         let classCacheCount = context.classCache.size;
         env.DEBUG && console.time('Generate rules');
-        let rules = (0, _generateRules).generateRules(candidates, context);
+        env.DEBUG && console.time('Sorting candidates');
+        // TODO: only sort if we are not using the oxide parser (flagEnabled(context.tailwindConfig,
+        // 'oxideParser')) AND if we got all the candidates form the oxideParser alone. This will not
+        // be the case currently if you have custom transformers / extractors.
+        let sortedCandidates = new Set([
+            ...candidates
+        ].sort((a, z)=>{
+            if (a === z) return 0;
+            if (a < z) return -1;
+            return 1;
+        }));
+        env.DEBUG && console.timeEnd('Sorting candidates');
+        (0, _generateRules.generateRules)(sortedCandidates, context);
         env.DEBUG && console.timeEnd('Generate rules');
         // We only ever add to the classCache, so if it didn't grow, there is nothing new.
         env.DEBUG && console.time('Build stylesheet');
         if (context.stylesheetCache === null || context.classCache.size !== classCacheCount) {
-            for (let rule of rules){
-                context.ruleCache.add(rule);
-            }
             context.stylesheetCache = buildStylesheet([
                 ...context.ruleCache
             ], context);
         }
         env.DEBUG && console.timeEnd('Build stylesheet');
-        let { defaults: defaultNodes , base: baseNodes , components: componentNodes , utilities: utilityNodes , variants: screenNodes ,  } = context.stylesheetCache;
+        let { defaults: defaultNodes, base: baseNodes, components: componentNodes, utilities: utilityNodes, variants: screenNodes } = context.stylesheetCache;
         // ---
         // Replace any Tailwind directives with generated CSS
         if (layerNodes.base) {
-            layerNodes.base.before((0, _cloneNodes).default([
+            layerNodes.base.before((0, _cloneNodes.default)([
                 ...baseNodes,
                 ...defaultNodes
             ], layerNodes.base.source, {
@@ -197,7 +239,7 @@ function expandTailwindAtRules(context) {
             layerNodes.base.remove();
         }
         if (layerNodes.components) {
-            layerNodes.components.before((0, _cloneNodes).default([
+            layerNodes.components.before((0, _cloneNodes.default)([
                 ...componentNodes
             ], layerNodes.components.source, {
                 layer: 'components'
@@ -205,7 +247,7 @@ function expandTailwindAtRules(context) {
             layerNodes.components.remove();
         }
         if (layerNodes.utilities) {
-            layerNodes.utilities.before((0, _cloneNodes).default([
+            layerNodes.utilities.before((0, _cloneNodes.default)([
                 ...utilityNodes
             ], layerNodes.utilities.source, {
                 layer: 'utilities'
@@ -214,8 +256,8 @@ function expandTailwindAtRules(context) {
         }
         // We do post-filtering to not alter the emitted order of the variants
         const variantNodes = Array.from(screenNodes).filter((node)=>{
-            var ref;
-            const parentLayer = (ref = node.raws.tailwind) === null || ref === void 0 ? void 0 : ref.parentLayer;
+            var _node_raws_tailwind;
+            const parentLayer = (_node_raws_tailwind = node.raws.tailwind) === null || _node_raws_tailwind === void 0 ? void 0 : _node_raws_tailwind.parentLayer;
             if (parentLayer === 'components') {
                 return layerNodes.components !== null;
             }
@@ -225,30 +267,41 @@ function expandTailwindAtRules(context) {
             return true;
         });
         if (layerNodes.variants) {
-            layerNodes.variants.before((0, _cloneNodes).default(variantNodes, layerNodes.variants.source, {
+            layerNodes.variants.before((0, _cloneNodes.default)(variantNodes, layerNodes.variants.source, {
                 layer: 'variants'
             }));
             layerNodes.variants.remove();
         } else if (variantNodes.length > 0) {
-            root.append((0, _cloneNodes).default(variantNodes, root.source, {
+            let cloned = (0, _cloneNodes.default)(variantNodes, undefined, {
                 layer: 'variants'
-            }));
+            });
+            cloned.forEach((node)=>{
+                var _node_raws_tailwind;
+                var _node_raws_tailwind_parentLayer;
+                let parentLayer = (_node_raws_tailwind_parentLayer = (_node_raws_tailwind = node.raws.tailwind) === null || _node_raws_tailwind === void 0 ? void 0 : _node_raws_tailwind.parentLayer) !== null && _node_raws_tailwind_parentLayer !== void 0 ? _node_raws_tailwind_parentLayer : null;
+                node.walk((n)=>{
+                    if (!n.source) {
+                        n.source = layerNodes[parentLayer].source;
+                    }
+                });
+            });
+            root.append(cloned);
         }
         // If we've got a utility layer and no utilities are generated there's likely something wrong
         const hasUtilityVariants = variantNodes.some((node)=>{
-            var ref;
-            return ((ref = node.raws.tailwind) === null || ref === void 0 ? void 0 : ref.parentLayer) === 'utilities';
+            var _node_raws_tailwind;
+            return ((_node_raws_tailwind = node.raws.tailwind) === null || _node_raws_tailwind === void 0 ? void 0 : _node_raws_tailwind.parentLayer) === 'utilities';
         });
         if (layerNodes.utilities && utilityNodes.size === 0 && !hasUtilityVariants) {
             _log.default.warn('content-problems', [
                 'No utility classes were detected in your source files. If this is unexpected, double-check the `content` option in your Tailwind CSS configuration.',
-                'https://tailwindcss.com/docs/content-configuration', 
+                'https://tailwindcss.com/docs/content-configuration'
             ]);
         }
         // ---
         if (env.DEBUG) {
             console.log('Potential classes: ', candidates.size);
-            console.log('Active contexts: ', sharedState.contextSourcesMap.size);
+            console.log('Active contexts: ', _sharedState.contextSourcesMap.size);
         }
         // Clear the cache for the changed files
         context.changedContent = [];

package/lib/lib/findAtConfigPath.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "findAtConfigPath", {
+    enumerable: true,
+    get: function() {
+        return findAtConfigPath;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function findAtConfigPath(root, result) {
+    let configPath = null;
+    let relativeTo = null;
+    root.walkAtRules('config', (rule)=>{
+        var _rule_source;
+        var _rule_source_input_file, _ref;
+        relativeTo = (_ref = (_rule_source_input_file = (_rule_source = rule.source) === null || _rule_source === void 0 ? void 0 : _rule_source.input.file) !== null && _rule_source_input_file !== void 0 ? _rule_source_input_file : result.opts.from) !== null && _ref !== void 0 ? _ref : null;
+        if (relativeTo === null) {
+            throw rule.error('The `@config` directive cannot be used without setting `from` in your PostCSS config.');
+        }
+        if (configPath) {
+            throw rule.error('Only one `@config` directive is allowed per file.');
+        }
+        let matches = rule.params.match(/(['"])(.*?)\1/);
+        if (!matches) {
+            throw rule.error('A path is required when using the `@config` directive.');
+        }
+        let inputPath = matches[2];
+        if (_path.default.isAbsolute(inputPath)) {
+            throw rule.error('The `@config` directive cannot be used with an absolute path.');
+        }
+        configPath = _path.default.resolve(_path.default.dirname(relativeTo), inputPath);
+        if (!_fs.default.existsSync(configPath)) {
+            throw rule.error(`The config file at "${inputPath}" does not exist. Make sure the path is correct and the file exists.`);
+        }
+        rule.remove();
+    });
+    return configPath ? configPath : null;
+}