tailwindcss 0.0.0-insiders.fe08e91 → 0.0.0-oxide.6d7c311

package/lib/lib/expandTailwindAtRules.js

@@ -2,54 +2,73 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = expandTailwindAtRules;
-exports.DEFAULTS_LAYER = void 0;
-var _quickLru = _interopRequireDefault(require("quick-lru"));
-var sharedState = _interopRequireWildcard(require("./sharedState"));
-var _generateRules = require("./generateRules");
-var _bigSign = _interopRequireDefault(require("../util/bigSign"));
-var _cloneNodes = _interopRequireDefault(require("../util/cloneNodes"));
-var _defaultExtractor = require("./defaultExtractor");
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: ()=>expandTailwindAtRules
+});
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _quickLru = /*#__PURE__*/ _interopRequireDefault(require("quick-lru"));
+const _sharedState = /*#__PURE__*/ _interopRequireWildcard(require("./sharedState"));
+const _generateRules = require("./generateRules");
+const _log = /*#__PURE__*/ _interopRequireDefault(require("../util/log"));
+const _cloneNodes = /*#__PURE__*/ _interopRequireDefault(require("../util/cloneNodes"));
+const _defaultExtractor = require("./defaultExtractor");
+const _oxide = /*#__PURE__*/ _interopRequireDefault(require("@tailwindcss/oxide"));
 function _interopRequireDefault(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 _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
         return obj;
-    } else {
-        var newObj = {
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
         };
-        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];
-                    }
-                }
+    }
+    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
-    ,
-    svelte: (content)=>content.replace(/(?:^|\s)class:/g, ' ')
+    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] || builtInExtractors.DEFAULT(context);
 }
 function getTransformer(tailwindConfig, fileExtension) {
     let transformers = tailwindConfig.content.transform;
@@ -65,7 +84,7 @@ function getClassCandidates(content, extractor, candidates, seen) {
             maxSize: 25000
         }));
     }
-    for (let line of content.split('\n')){
+    for (let line of content.split("\n")){
         line = line.trim();
         if (seen.has(line)) {
             continue;
@@ -76,65 +95,33 @@ 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);
+            for (let match1 of lineMatchesSet){
+                candidates.add(match1);
             }
             extractorCache.get(extractor).set(line, lineMatchesSet);
         }
     }
 }
-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;
 }
-const DEFAULTS_LAYER = Symbol('defaults-layer');
-exports.DEFAULTS_LAYER = DEFAULTS_LAYER;
 function expandTailwindAtRules(context) {
     return (root)=>{
         let layerNodes = {
@@ -143,113 +130,143 @@ function expandTailwindAtRules(context) {
             utilities: null,
             variants: null
         };
-        // let hasApply = false
         root.walkAtRules((rule)=>{
             // Make sure this file contains Tailwind directives. If not, we can save
             // a lot of work and bail early. Also we don't have to register our touch
             // file as a dependency since the output of this CSS does not depend on
             // the source of any templates. Think Vue <style> blocks for example.
-            if (rule.name === 'tailwind') {
+            if (rule.name === "tailwind") {
                 if (Object.keys(layerNodes).includes(rule.params)) {
                     layerNodes[rule.params] = rule;
                 }
             }
-        // We also want to check for @apply because the user can
-        // apply classes in an isolated environment like CSS
-        // modules and we still need to inject defaults
-        // if (rule.name === 'apply') {
-        //   hasApply = true
-        // }
         });
-        if (Object.values(layerNodes).every((n)=>n === null
-        )) {
+        if (Object.values(layerNodes).every((n)=>n === null)) {
             return root;
         }
+        var _candidates;
         // ---
         // Find potential rules in changed files
         let candidates = new Set([
-            '*'
+            ...(_candidates = context.candidates) !== null && _candidates !== void 0 ? _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);
+        env.DEBUG && console.time("Reading changed files");
+        if (env.OXIDE) {
+            // TODO: Pass through or implement `extractor`
+            for (let candidate of _oxide.default.parseCandidateStringsFromFiles(context.changedContent)){
+                candidates.add(candidate);
+            }
+        // for (let { file, content, extension } of context.changedContent) {
+        //   let transformer = getTransformer(context.tailwindConfig, extension)
+        //   let extractor = getExtractor(context, extension)
+        //   getClassCandidatesOxide(file, transformer(content), extractor, candidates, seen)
+        // }
+        } else {
+            for (let { file , content , extension  } of context.changedContent){
+                let transformer = getTransformer(context.tailwindConfig, extension);
+                let extractor = getExtractor(context, extension);
+                content = file ? _fs.default.readFileSync(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.timeEnd('Generate rules');
+        env.DEBUG && console.time("Generate rules");
+        // TODO: Sorting is _probably_ slow, but right now it can guarantee the same order. Eventually
+        // we will be able to get rid of this.
+        env.DEBUG && console.time("Sorting candidates");
+        let sortedCandidates = typeof process !== "undefined" && process.env.JEST_WORKER_ID ? new Set([
+            ...candidates
+        ].sort((a, z)=>{
+            if (a === z) return 0;
+            if (a < z) return -1;
+            return 1;
+        })) : candidates;
+        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');
+        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;
+        env.DEBUG && console.timeEnd("Build stylesheet");
+        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([
-                ...baseNodes
-            ], layerNodes.base.source));
-        }
-        // @defaults rules are unconditionally added first to ensure that
-        // using any utility that relies on defaults will work even when
-        // compiled in an isolated environment like CSS modules
-        if (context.tailwindConfig[DEFAULTS_LAYER] !== false) {
-            if (layerNodes.base) {
-                layerNodes.base.after((0, _cloneNodes).default([
-                    ...defaultNodes
-                ], root.source));
-            } else {
-                root.prepend((0, _cloneNodes).default([
-                    ...defaultNodes
-                ], root.source));
-            }
-        }
-        if (layerNodes.base) {
+            layerNodes.base.before((0, _cloneNodes.default)([
+                ...baseNodes,
+                ...defaultNodes
+            ], layerNodes.base.source, {
+                layer: "base"
+            }));
             layerNodes.base.remove();
         }
         if (layerNodes.components) {
-            layerNodes.components.before((0, _cloneNodes).default([
+            layerNodes.components.before((0, _cloneNodes.default)([
                 ...componentNodes
-            ], layerNodes.components.source));
+            ], layerNodes.components.source, {
+                layer: "components"
+            }));
             layerNodes.components.remove();
         }
         if (layerNodes.utilities) {
-            layerNodes.utilities.before((0, _cloneNodes).default([
+            layerNodes.utilities.before((0, _cloneNodes.default)([
                 ...utilityNodes
-            ], layerNodes.utilities.source));
+            ], layerNodes.utilities.source, {
+                layer: "utilities"
+            }));
             layerNodes.utilities.remove();
         }
+        // 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;
+            if (parentLayer === "components") {
+                return layerNodes.components !== null;
+            }
+            if (parentLayer === "utilities") {
+                return layerNodes.utilities !== null;
+            }
+            return true;
+        });
         if (layerNodes.variants) {
-            layerNodes.variants.before((0, _cloneNodes).default([
-                ...screenNodes
-            ], layerNodes.variants.source));
+            layerNodes.variants.before((0, _cloneNodes.default)(variantNodes, layerNodes.variants.source, {
+                layer: "variants"
+            }));
             layerNodes.variants.remove();
-        } else {
-            root.append((0, _cloneNodes).default([
-                ...screenNodes
-            ], root.source));
+        } else if (variantNodes.length > 0) {
+            root.append((0, _cloneNodes.default)(variantNodes, root.source, {
+                layer: "variants"
+            }));
+        }
+        // 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";
+        });
+        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"
+            ]);
         }
         // ---
         if (env.DEBUG) {
-            console.log('Potential classes: ', candidates.size);
-            console.log('Active contexts: ', sharedState.contextSourcesMap.size);
+            console.log("Potential classes: ", candidates.size);
+            console.log("Active contexts: ", _sharedState.contextSourcesMap.size);
         }
         // Clear the cache for the changed files
         context.changedContent = [];
         // Cleanup any leftover @layer atrules
-        root.walkAtRules('layer', (rule)=>{
+        root.walkAtRules("layer", (rule)=>{
             if (Object.keys(layerNodes).includes(rule.params)) {
                 rule.remove();
             }

package/lib/lib/findAtConfigPath.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "findAtConfigPath", {
+    enumerable: true,
+    get: ()=>findAtConfigPath
+});
+const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function findAtConfigPath(root, result) {
+    let configPath = null;
+    let relativeTo = null;
+    root.walkAtRules("config", (rule)=>{
+        var ref;
+        var _file, ref1;
+        relativeTo = (ref1 = (_file = (ref = rule.source) === null || ref === void 0 ? void 0 : ref.input.file) !== null && _file !== void 0 ? _file : result.opts.from) !== null && ref1 !== void 0 ? ref1 : 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;
+}