tailwindcss 0.0.0-oxide-insiders.a7fe2fe → 0.0.0-oxide-insiders.7f555c4

package/lib/lib/setupTrackingContext.js

@@ -1,74 +1,165 @@
+// @ts-check
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>setupTrackingContext
+    value: true
 });
-const _fs = _interopRequireDefault(require("fs")), _quickLru = _interopRequireDefault(require("quick-lru")), _hashConfig = _interopRequireDefault(require("../util/hashConfig")), _resolveConfig = _interopRequireDefault(require("../public/resolve-config")), _resolveConfigPath = _interopRequireDefault(require("../util/resolveConfigPath")), _setupContextUtils = require("./setupContextUtils"), _parseDependency = _interopRequireDefault(require("../util/parseDependency")), _validateConfigJs = require("../util/validateConfig.js"), _contentJs = require("./content.js"), _loadConfig = require("../lib/load-config"), _getModuleDependencies = _interopRequireDefault(require("./getModuleDependencies"));
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, // DISABLE_TOUCH = TRUE
+// Retrieve an existing context from cache if possible (since contexts are unique per
+// source path), or set up a new one (including setting up watchers and registering
+// plugins) then return it
+"default", {
+    enumerable: true,
+    get: function() {
+        return setupTrackingContext;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _quicklru = /*#__PURE__*/ _interop_require_default(require("@alloc/quick-lru"));
+const _hashConfig = /*#__PURE__*/ _interop_require_default(require("../util/hashConfig"));
+const _resolveconfig = /*#__PURE__*/ _interop_require_default(require("../public/resolve-config"));
+const _resolveConfigPath = /*#__PURE__*/ _interop_require_default(require("../util/resolveConfigPath"));
+const _setupContextUtils = require("./setupContextUtils");
+const _parseDependency = /*#__PURE__*/ _interop_require_default(require("../util/parseDependency"));
+const _validateConfig = require("../util/validateConfig.js");
+const _content = require("./content.js");
+const _loadconfig = require("../lib/load-config");
+const _getModuleDependencies = /*#__PURE__*/ _interop_require_default(require("./getModuleDependencies"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-let configPathCache = new _quickLru.default({
+let configPathCache = new _quicklru.default({
     maxSize: 100
-}), candidateFilesCache = new WeakMap();
+});
+let candidateFilesCache = new WeakMap();
+function getCandidateFiles(context, tailwindConfig) {
+    if (candidateFilesCache.has(context)) {
+        return candidateFilesCache.get(context);
+    }
+    let candidateFiles = (0, _content.parseCandidateFiles)(context, tailwindConfig);
+    return candidateFilesCache.set(context, candidateFiles).get(context);
+}
+// Get the config object based on a path
+function getTailwindConfig(configOrPath) {
+    let userConfigPath = (0, _resolveConfigPath.default)(configOrPath);
+    if (userConfigPath !== null) {
+        let [prevConfig, prevConfigHash, prevDeps, prevModified] = configPathCache.get(userConfigPath) || [];
+        let newDeps = (0, _getModuleDependencies.default)(userConfigPath);
+        let modified = false;
+        let newModified = new Map();
+        for (let file of newDeps){
+            let time = _fs.default.statSync(file).mtimeMs;
+            newModified.set(file, time);
+            if (!prevModified || !prevModified.has(file) || time > prevModified.get(file)) {
+                modified = true;
+            }
+        }
+        // It hasn't changed (based on timestamps)
+        if (!modified) {
+            return [
+                prevConfig,
+                userConfigPath,
+                prevConfigHash,
+                prevDeps
+            ];
+        }
+        // It has changed (based on timestamps), or first run
+        for (let file of newDeps){
+            delete require.cache[file];
+        }
+        let newConfig = (0, _validateConfig.validateConfig)((0, _resolveconfig.default)((0, _loadconfig.loadConfig)(userConfigPath)));
+        let newHash = (0, _hashConfig.default)(newConfig);
+        configPathCache.set(userConfigPath, [
+            newConfig,
+            newHash,
+            newDeps,
+            newModified
+        ]);
+        return [
+            newConfig,
+            userConfigPath,
+            newHash,
+            newDeps
+        ];
+    }
+    // It's a plain object, not a path
+    let newConfig = (0, _resolveconfig.default)(configOrPath.config === undefined ? configOrPath : configOrPath.config);
+    newConfig = (0, _validateConfig.validateConfig)(newConfig);
+    return [
+        newConfig,
+        null,
+        (0, _hashConfig.default)(newConfig),
+        []
+    ];
+}
 function setupTrackingContext(configOrPath) {
-    return ({ tailwindDirectives , registerDependency  })=>(root, result)=>{
-            let [tailwindConfig, userConfigPath, tailwindConfigHash, configDependencies] = function(configOrPath) {
-                let userConfigPath = (0, _resolveConfigPath.default)(configOrPath);
-                if (null !== userConfigPath) {
-                    let [prevConfig, prevConfigHash, prevDeps, prevModified] = configPathCache.get(userConfigPath) || [], newDeps = (0, _getModuleDependencies.default)(userConfigPath), modified = !1, newModified = new Map();
-                    for (let file of newDeps){
-                        let time = _fs.default.statSync(file).mtimeMs;
-                        newModified.set(file, time), (!prevModified || !prevModified.has(file) || time > prevModified.get(file)) && (modified = !0);
+    return ({ tailwindDirectives , registerDependency  })=>{
+        return (root, result)=>{
+            let [tailwindConfig, userConfigPath, tailwindConfigHash, configDependencies] = getTailwindConfig(configOrPath);
+            let contextDependencies = new Set(configDependencies);
+            // If there are no @tailwind or @apply rules, we don't consider this CSS
+            // file or its dependencies to be dependencies of the context. Can reuse
+            // the context even if they change. We may want to think about `@layer`
+            // being part of this trigger too, but it's tough because it's impossible
+            // for a layer in one file to end up in the actual @tailwind rule in
+            // another file since independent sources are effectively isolated.
+            if (tailwindDirectives.size > 0) {
+                // Add current css file as a context dependencies.
+                contextDependencies.add(result.opts.from);
+                // Add all css @import dependencies as context dependencies.
+                for (let message of result.messages){
+                    if (message.type === "dependency") {
+                        contextDependencies.add(message.file);
                     }
-                    if (!modified) return [
-                        prevConfig,
-                        userConfigPath,
-                        prevConfigHash,
-                        prevDeps
-                    ];
-                    for (let file of newDeps)delete require.cache[file];
-                    let newConfig = (0, _validateConfigJs.validateConfig)((0, _resolveConfig.default)((0, _loadConfig.loadConfig)(userConfigPath))), newHash = (0, _hashConfig.default)(newConfig);
-                    return configPathCache.set(userConfigPath, [
-                        newConfig,
-                        newHash,
-                        newDeps,
-                        newModified
-                    ]), [
-                        newConfig,
-                        userConfigPath,
-                        newHash,
-                        newDeps
-                    ];
                 }
-                let newConfig = (0, _resolveConfig.default)(void 0 === configOrPath.config ? configOrPath : configOrPath.config);
-                return [
-                    newConfig = (0, _validateConfigJs.validateConfig)(newConfig),
-                    null,
-                    (0, _hashConfig.default)(newConfig),
-                    []
-                ];
-            }(configOrPath), contextDependencies = new Set(configDependencies);
-            if (tailwindDirectives.size > 0) for (let message of (contextDependencies.add(result.opts.from), result.messages))"dependency" === message.type && contextDependencies.add(message.file);
-            let [context, , mTimesToCommit] = (0, _setupContextUtils.getContext)(root, result, tailwindConfig, userConfigPath, tailwindConfigHash, contextDependencies), fileModifiedMap = (0, _setupContextUtils.getFileModifiedMap)(context), candidateFiles = function(context, tailwindConfig) {
-                if (candidateFilesCache.has(context)) return candidateFilesCache.get(context);
-                let candidateFiles = (0, _contentJs.parseCandidateFiles)(context, tailwindConfig);
-                return candidateFilesCache.set(context, candidateFiles).get(context);
-            }(context, tailwindConfig);
+            }
+            let [context, , mTimesToCommit] = (0, _setupContextUtils.getContext)(root, result, tailwindConfig, userConfigPath, tailwindConfigHash, contextDependencies);
+            let fileModifiedMap = (0, _setupContextUtils.getFileModifiedMap)(context);
+            let candidateFiles = getCandidateFiles(context, tailwindConfig);
+            // If there are no @tailwind or @apply rules, we don't consider this CSS file or it's
+            // dependencies to be dependencies of the context. Can reuse the context even if they change.
+            // We may want to think about `@layer` being part of this trigger too, but it's tough
+            // because it's impossible for a layer in one file to end up in the actual @tailwind rule
+            // in another file since independent sources are effectively isolated.
             if (tailwindDirectives.size > 0) {
-                for (let contentPath of candidateFiles)for (let dependency of (0, _parseDependency.default)(contentPath))registerDependency(dependency);
-                let [changedContent, contentMTimesToCommit] = (0, _contentJs.resolvedChangedContent)(context, candidateFiles, fileModifiedMap);
-                for (let content of changedContent)context.changedContent.push(content);
-                for (let [path, mtime] of contentMTimesToCommit.entries())mTimesToCommit.set(path, mtime);
+                // Add template paths as postcss dependencies.
+                for (let contentPath of candidateFiles){
+                    for (let dependency of (0, _parseDependency.default)(contentPath)){
+                        registerDependency(dependency);
+                    }
+                }
+                let [changedContent, contentMTimesToCommit] = (0, _content.resolvedChangedContent)(context, candidateFiles, fileModifiedMap);
+                for (let content of changedContent){
+                    context.changedContent.push(content);
+                }
+                // Add the mtimes of the content files to the commit list
+                // We can overwrite the existing values because unconditionally
+                // This is because:
+                // 1. Most of the files here won't be in the map yet
+                // 2. If they are that means it's a context dependency
+                // and we're reading this after the context. This means
+                // that the mtime we just read is strictly >= the context
+                // mtime. Unless the user / os is doing something weird
+                // in which the mtime would be going backwards. If that
+                // happens there's already going to be problems.
+                for (let [path, mtime] of contentMTimesToCommit.entries()){
+                    mTimesToCommit.set(path, mtime);
+                }
+            }
+            for (let file of configDependencies){
+                registerDependency({
+                    type: "dependency",
+                    file
+                });
+            }
+            // "commit" the new modified time for all context deps
+            // We do this here because we want content tracking to
+            // read the "old" mtime even when it's a context dependency.
+            for (let [path, mtime] of mTimesToCommit.entries()){
+                fileModifiedMap.set(path, mtime);
             }
-            for (let file of configDependencies)registerDependency({
-                type: "dependency",
-                file
-            });
-            for (let [path, mtime] of mTimesToCommit.entries())fileModifiedMap.set(path, mtime);
             return context;
         };
+    };
 }

package/lib/lib/sharedState.js

@@ -1,39 +1,87 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), function(target, all) {
+    value: true
+});
+function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: !0,
+        enumerable: true,
         get: all[name]
     });
-}(exports, {
-    env: ()=>env,
-    contextMap: ()=>contextMap,
-    configContextMap: ()=>configContextMap,
-    contextSourcesMap: ()=>contextSourcesMap,
-    sourceHashMap: ()=>sourceHashMap,
-    NOT_ON_DEMAND: ()=>NOT_ON_DEMAND,
-    NONE: ()=>NONE,
-    resolveDebug: ()=>resolveDebug
+}
+_export(exports, {
+    env: function() {
+        return env;
+    },
+    contextMap: function() {
+        return contextMap;
+    },
+    configContextMap: function() {
+        return configContextMap;
+    },
+    contextSourcesMap: function() {
+        return contextSourcesMap;
+    },
+    sourceHashMap: function() {
+        return sourceHashMap;
+    },
+    NOT_ON_DEMAND: function() {
+        return NOT_ON_DEMAND;
+    },
+    NONE: function() {
+        return NONE;
+    },
+    resolveDebug: function() {
+        return resolveDebug;
+    }
 });
-const _packageJson = function(obj) {
+const _packagejson = /*#__PURE__*/ _interop_require_default(require("../../package.json"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}(require("../../package.json")), env = "undefined" != typeof process ? {
+}
+const env = typeof process !== "undefined" ? {
     NODE_ENV: process.env.NODE_ENV,
     DEBUG: resolveDebug(process.env.DEBUG),
-    ENGINE: _packageJson.default.tailwindcss.engine
+    ENGINE: _packagejson.default.tailwindcss.engine
 } : {
     NODE_ENV: "production",
-    DEBUG: !1,
-    ENGINE: _packageJson.default.tailwindcss.engine
-}, contextMap = new Map(), configContextMap = new Map(), contextSourcesMap = new Map(), sourceHashMap = new Map(), NOT_ON_DEMAND = new String("*"), NONE = Symbol("__NONE__");
+    DEBUG: false,
+    ENGINE: _packagejson.default.tailwindcss.engine
+};
+const contextMap = new Map();
+const configContextMap = new Map();
+const contextSourcesMap = new Map();
+const sourceHashMap = new Map();
+const NOT_ON_DEMAND = new String("*");
+const NONE = Symbol("__NONE__");
 function resolveDebug(debug) {
-    if (void 0 === debug) return !1;
-    if ("true" === debug || "1" === debug) return !0;
-    if ("false" === debug || "0" === debug) return !1;
-    if ("*" === debug) return !0;
+    if (debug === undefined) {
+        return false;
+    }
+    // Environment variables are strings, so convert to boolean
+    if (debug === "true" || debug === "1") {
+        return true;
+    }
+    if (debug === "false" || debug === "0") {
+        return false;
+    }
+    // Keep the debug convention into account:
+    // DEBUG=* -> This enables all debug modes
+    // DEBUG=projectA,projectB,projectC -> This enables debug for projectA, projectB and projectC
+    // DEBUG=projectA:* -> This enables all debug modes for projectA (if you have sub-types)
+    // DEBUG=projectA,-projectB -> This enables debug for projectA and explicitly disables it for projectB
+    if (debug === "*") {
+        return true;
+    }
     let debuggers = debug.split(",").map((d)=>d.split(":")[0]);
-    return !debuggers.includes("-tailwindcss") && !!debuggers.includes("tailwindcss");
+    // Ignoring tailwindcss
+    if (debuggers.includes("-tailwindcss")) {
+        return false;
+    }
+    // Including tailwindcss
+    if (debuggers.includes("tailwindcss")) {
+        return true;
+    }
+    return false;
 }

package/lib/lib/substituteScreenAtRules.js

@@ -1,21 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "default", {
-    enumerable: !0,
-    get: ()=>_default
+    value: true
 });
-const _normalizeScreens = require("../util/normalizeScreens"), _buildMediaQuery = function(obj) {
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _normalizeScreens = require("../util/normalizeScreens");
+const _buildMediaQuery = /*#__PURE__*/ _interop_require_default(require("../util/buildMediaQuery"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}(require("../util/buildMediaQuery"));
+}
 function _default({ tailwindConfig: { theme  }  }) {
     return function(css) {
         css.walkAtRules("screen", (atRule)=>{
-            let screen = atRule.params, screenDefinition = (0, _normalizeScreens.normalizeScreens)(theme.screens).find(({ name  })=>name === screen);
-            if (!screenDefinition) throw atRule.error(`No \`${screen}\` screen found.`);
-            atRule.name = "media", atRule.params = (0, _buildMediaQuery.default)(screenDefinition);
+            let screen = atRule.params;
+            let screens = (0, _normalizeScreens.normalizeScreens)(theme.screens);
+            let screenDefinition = screens.find(({ name  })=>name === screen);
+            if (!screenDefinition) {
+                throw atRule.error(`No \`${screen}\` screen found.`);
+            }
+            atRule.name = "media";
+            atRule.params = (0, _buildMediaQuery.default)(screenDefinition);
         });
     };
 }

package/lib/oxide/cli/build/deps.js

@@ -1,64 +1,87 @@
 "use strict";
-let lightningCss;
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), function(target, all) {
+    value: true
+});
+function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
-        enumerable: !0,
+        enumerable: true,
         get: all[name]
     });
-}(exports, {
-    lazyLightningCss: ()=>lazyLightningCss,
-    lightningcss: ()=>lightningcss,
-    loadPostcss: ()=>loadPostcss,
-    loadPostcssImport: ()=>loadPostcssImport
+}
+_export(exports, {
+    lazyLightningCss: function() {
+        return lazyLightningCss;
+    },
+    lightningcss: function() {
+        return lightningcss;
+    },
+    loadPostcss: function() {
+        return loadPostcss;
+    },
+    loadPostcssImport: function() {
+        return loadPostcssImport;
+    }
 });
-const _packageJson = _interopRequireDefault(require("../../../../package.json")), _browserslist = _interopRequireDefault(require("browserslist")), _index = require("../../../../peers/index");
-function _interopRequireDefault(obj) {
+const _packagejson = /*#__PURE__*/ _interop_require_default(require("../../../../package.json"));
+const _browserslist = /*#__PURE__*/ _interop_require_default(require("browserslist"));
+const _index = require("../../../../peers/index");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 function lazyLightningCss() {
+    // TODO: Make this lazy/bundled
     return require("lightningcss");
 }
+let lightningCss;
+function loadLightningCss() {
+    if (lightningCss) {
+        return lightningCss;
+    }
+    // Try to load a local version first
+    try {
+        return lightningCss = require("lightningcss");
+    } catch  {}
+    return lightningCss = lazyLightningCss();
+}
 async function lightningcss(shouldMinify, result) {
-    let css = function() {
-        if (lightningCss) return lightningCss;
-        try {
-            return lightningCss = require("lightningcss");
-        } catch  {}
-        return lightningCss = lazyLightningCss();
-    }();
+    let css = loadLightningCss();
     try {
         let transformed = css.transform({
             filename: result.opts.from || "input.css",
             code: Buffer.from(result.css, "utf-8"),
             minify: shouldMinify,
             sourceMap: !!result.map,
-            inputSourceMap: result.map ? result.map.toString() : void 0,
-            targets: css.browserslistToTargets((0, _browserslist.default)(_packageJson.default.browserslist)),
+            inputSourceMap: result.map ? result.map.toString() : undefined,
+            targets: css.browserslistToTargets((0, _browserslist.default)(_packagejson.default.browserslist)),
             drafts: {
-                nesting: !0
+                nesting: true
             }
         });
         return Object.assign(result, {
             css: transformed.code.toString("utf8"),
             map: result.map ? Object.assign(result.map, {
-                toString: ()=>transformed.map.toString()
+                toString () {
+                    return transformed.map.toString();
+                }
             }) : result.map
         });
     } catch (err) {
-        return console.error("Unable to use Lightning CSS. Using raw version instead."), console.error(err), result;
+        console.error("Unable to use Lightning CSS. Using raw version instead.");
+        console.error(err);
+        return result;
     }
 }
 function loadPostcss() {
+    // Try to load a local `postcss` version first
     try {
         return require("postcss");
     } catch  {}
     return (0, _index.lazyPostcss)();
 }
 function loadPostcssImport() {
+    // Try to load a local `postcss-import` version first
     try {
         return require("postcss-import");
     } catch  {}

package/lib/oxide/cli/build/index.js

@@ -1,21 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "build", {
-    enumerable: !0,
-    get: ()=>build
+    value: true
 });
-const _fs = _interopRequireDefault(require("fs")), _path = _interopRequireDefault(require("path")), _resolveConfigPath = require("../../../util/resolveConfigPath"), _plugin = require("./plugin");
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, "build", {
+    enumerable: true,
+    get: function() {
+        return build;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _resolveConfigPath = require("../../../util/resolveConfigPath");
+const _plugin = require("./plugin");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 async function build(args) {
-    let input = args["--input"], shouldWatch = args["--watch"];
-    !input && args._[1] && (console.error("[deprecation] Running tailwindcss without -i, please provide an input file."), input = args["--input"] = args._[1]), input && "-" !== input && !_fs.default.existsSync(input = _path.default.resolve(input)) && (console.error(`Specified input file ${args["--input"]} does not exist.`), process.exit(9)), args["--config"] && !_fs.default.existsSync(args["--config"] = _path.default.resolve(args["--config"])) && (console.error(`Specified config file ${args["--config"]} does not exist.`), process.exit(9));
-    let configPath = args["--config"] ? args["--config"] : (0, _resolveConfigPath.resolveDefaultConfigPath)(), processor = await (0, _plugin.createProcessor)(args, configPath);
-    shouldWatch ? ("always" !== args["--watch"] && process.stdin.on("end", ()=>process.exit(0)), process.stdin.resume(), await processor.watch()) : await processor.build().catch((e)=>{
-        console.error(e), process.exit(1);
-    });
+    let input = args["--input"];
+    let shouldWatch = args["--watch"];
+    // TODO: Deprecate this in future versions
+    if (!input && args["_"][1]) {
+        console.error("[deprecation] Running tailwindcss without -i, please provide an input file.");
+        input = args["--input"] = args["_"][1];
+    }
+    if (input && input !== "-" && !_fs.default.existsSync(input = _path.default.resolve(input))) {
+        console.error(`Specified input file ${args["--input"]} does not exist.`);
+        process.exit(9);
+    }
+    if (args["--config"] && !_fs.default.existsSync(args["--config"] = _path.default.resolve(args["--config"]))) {
+        console.error(`Specified config file ${args["--config"]} does not exist.`);
+        process.exit(9);
+    }
+    // TODO: Reference the @config path here if exists
+    let configPath = args["--config"] ? args["--config"] : (0, _resolveConfigPath.resolveDefaultConfigPath)();
+    let processor = await (0, _plugin.createProcessor)(args, configPath);
+    if (shouldWatch) {
+        // Abort the watcher if stdin is closed to avoid zombie processes
+        // You can disable this behavior with --watch=always
+        if (args["--watch"] !== "always") {
+            process.stdin.on("end", ()=>process.exit(0));
+        }
+        process.stdin.resume();
+        await processor.watch();
+    } else {
+        await processor.build().catch((e)=>{
+            console.error(e);
+            process.exit(1);
+        });
+    }
 }