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

package/lib/cli/build/utils.js

@@ -1,41 +1,66 @@
+// @ts-check
 "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, {
-    indentRecursive: ()=>indentRecursive,
-    formatNodes: ()=>formatNodes,
-    readFileWithRetries: ()=>readFileWithRetries,
-    drainStdin: ()=>drainStdin,
-    outputFile: ()=>outputFile
+}
+_export(exports, {
+    indentRecursive: function() {
+        return indentRecursive;
+    },
+    formatNodes: function() {
+        return formatNodes;
+    },
+    readFileWithRetries: function() {
+        return readFileWithRetries;
+    },
+    drainStdin: function() {
+        return drainStdin;
+    },
+    outputFile: function() {
+        return outputFile;
+    }
 });
-const _fs = _interopRequireDefault(require("fs")), _path = _interopRequireDefault(require("path"));
-function _interopRequireDefault(obj) {
+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 indentRecursive(node, indent = 0) {
     node.each && node.each((child, i)=>{
-        (!child.raws.before || !child.raws.before.trim() || child.raws.before.includes("\n")) && (child.raws.before = `\n${"rule" !== node.type && i > 0 ? "\n" : ""}${"  ".repeat(indent)}`), child.raws.after = `\n${"  ".repeat(indent)}`, indentRecursive(child, indent + 1);
+        if (!child.raws.before || !child.raws.before.trim() || child.raws.before.includes("\n")) {
+            child.raws.before = `\n${node.type !== "rule" && i > 0 ? "\n" : ""}${"  ".repeat(indent)}`;
+        }
+        child.raws.after = `\n${"  ".repeat(indent)}`;
+        indentRecursive(child, indent + 1);
     });
 }
 function formatNodes(root) {
-    indentRecursive(root), root.first && (root.first.raws.before = "");
+    indentRecursive(root);
+    if (root.first) {
+        root.first.raws.before = "";
+    }
 }
 async function readFileWithRetries(path, tries = 5) {
-    for(let n = 0; n <= tries; n++)try {
-        return await _fs.default.promises.readFile(path, "utf8");
-    } catch (err) {
-        if (n !== tries && ("ENOENT" === err.code || "EBUSY" === err.code)) {
-            await new Promise((resolve)=>setTimeout(resolve, 10));
-            continue;
+    for(let n = 0; n <= tries; n++){
+        try {
+            return await _fs.default.promises.readFile(path, "utf8");
+        } catch (err) {
+            if (n !== tries) {
+                if (err.code === "ENOENT" || err.code === "EBUSY") {
+                    await new Promise((resolve)=>setTimeout(resolve, 10));
+                    continue;
+                }
+            }
+            throw err;
         }
-        throw err;
     }
 }
 function drainStdin() {
@@ -43,14 +68,21 @@ function drainStdin() {
         let result = "";
         process.stdin.on("data", (chunk)=>{
             result += chunk;
-        }), process.stdin.on("end", ()=>resolve(result)), process.stdin.on("error", (err)=>reject(err));
+        });
+        process.stdin.on("end", ()=>resolve(result));
+        process.stdin.on("error", (err)=>reject(err));
     });
 }
 async function outputFile(file, newContents) {
     try {
-        if (await _fs.default.promises.readFile(file, "utf8") === newContents) return;
+        let currentContents = await _fs.default.promises.readFile(file, "utf8");
+        if (currentContents === newContents) {
+            return; // Skip writing the file
+        }
     } catch  {}
+    // Write the file
     await _fs.default.promises.mkdir(_path.default.dirname(file), {
-        recursive: !0
-    }), await _fs.default.promises.writeFile(file, newContents, "utf8");
+        recursive: true
+    });
+    await _fs.default.promises.writeFile(file, newContents, "utf8");
 }

package/lib/cli/build/watching.js

@@ -1,64 +1,182 @@
+// @ts-check
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "createWatcher", {
-    enumerable: !0,
-    get: ()=>createWatcher
+    value: true
 });
-const _chokidar = _interopRequireDefault(require("chokidar")), _fs = _interopRequireDefault(require("fs")), _micromatch = _interopRequireDefault(require("micromatch")), _normalizePath = _interopRequireDefault(require("normalize-path")), _path = _interopRequireDefault(require("path")), _utilsJs = require("./utils.js");
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, "createWatcher", {
+    enumerable: true,
+    get: function() {
+        return createWatcher;
+    }
+});
+const _chokidar = /*#__PURE__*/ _interop_require_default(require("chokidar"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _micromatch = /*#__PURE__*/ _interop_require_default(require("micromatch"));
+const _normalizepath = /*#__PURE__*/ _interop_require_default(require("normalize-path"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _utils = require("./utils.js");
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 function createWatcher(args, { state , rebuild  }) {
-    let _timer, _reject, shouldPoll = args["--poll"], shouldCoalesceWriteEvents = shouldPoll || "win32" === process.platform, watcher = _chokidar.default.watch([], {
-        atomic: !0,
+    let shouldPoll = args["--poll"];
+    let shouldCoalesceWriteEvents = shouldPoll || process.platform === "win32";
+    // Polling interval in milliseconds
+    // Used only when polling or coalescing add/change events on Windows
+    let pollInterval = 10;
+    let watcher = _chokidar.default.watch([], {
+        // Force checking for atomic writes in all situations
+        // This causes chokidar to wait up to 100ms for a file to re-added after it's been unlinked
+        // This only works when watching directories though
+        atomic: true,
         usePolling: shouldPoll,
-        interval: shouldPoll ? 10 : void 0,
-        ignoreInitial: !0,
-        awaitWriteFinish: !!shouldCoalesceWriteEvents && {
+        interval: shouldPoll ? pollInterval : undefined,
+        ignoreInitial: true,
+        awaitWriteFinish: shouldCoalesceWriteEvents ? {
             stabilityThreshold: 50,
-            pollInterval: 10
-        }
-    }), chain = Promise.resolve(), changedContent = [], pendingRebuilds = new Set();
-    async function rebuildAndContinue() {
+            pollInterval: pollInterval
+        } : false
+    });
+    // A queue of rebuilds, file reads, etc… to run
+    let chain = Promise.resolve();
+    /**
+   * A list of files that have been changed since the last rebuild
+   *
+   * @type {{file: string, content: () => Promise<string>, extension: string}[]}
+   */ let changedContent = [];
+    /**
+   * A list of files for which a rebuild has already been queued.
+   * This is used to prevent duplicate rebuilds when multiple events are fired for the same file.
+   * The rebuilt file is cleared from this list when it's associated rebuild has _started_
+   * This is because if the file is changed during a rebuild it won't trigger a new rebuild which it should
+   **/ let pendingRebuilds = new Set();
+    let _timer;
+    let _reject;
+    /**
+   * Rebuilds the changed files and resolves when the rebuild is
+   * complete regardless of whether it was successful or not
+   */ async function rebuildAndContinue() {
         let changes = changedContent.splice(0);
-        return 0 === changes.length ? Promise.resolve() : (changes.forEach((change)=>pendingRebuilds.delete(change.file)), rebuild(changes).then(()=>{}, (e)=>{
+        // There are no changes to rebuild so we can just do nothing
+        if (changes.length === 0) {
+            return Promise.resolve();
+        }
+        // Clear all pending rebuilds for the about-to-be-built files
+        changes.forEach((change)=>pendingRebuilds.delete(change.file));
+        // Resolve the promise even when the rebuild fails
+        return rebuild(changes).then(()=>{}, (e)=>{
             console.error(e.toString());
-        }));
+        });
     }
-    function recordChangedFile(file, content = null, skipPendingCheck = !1) {
-        return (file = _path.default.resolve(file), pendingRebuilds.has(file) && !skipPendingCheck) ? Promise.resolve() : (pendingRebuilds.add(file), changedContent.push({
+    /**
+   *
+   * @param {*} file
+   * @param {(() => Promise<string>) | null} content
+   * @param {boolean} skipPendingCheck
+   * @returns {Promise<void>}
+   */ function recordChangedFile(file, content = null, skipPendingCheck = false) {
+        file = _path.default.resolve(file);
+        // Applications like Vim/Neovim fire both rename and change events in succession for atomic writes
+        // In that case rebuild has already been queued by rename, so can be skipped in change
+        if (pendingRebuilds.has(file) && !skipPendingCheck) {
+            return Promise.resolve();
+        }
+        // Mark that a rebuild of this file is going to happen
+        // It MUST happen synchronously before the rebuild is queued for this to be effective
+        pendingRebuilds.add(file);
+        changedContent.push({
             file,
-            content: null != content ? content : ()=>_fs.default.promises.readFile(file, "utf8"),
+            content: content !== null && content !== void 0 ? content : ()=>_fs.default.promises.readFile(file, "utf8"),
             extension: _path.default.extname(file).slice(1)
-        }), _timer && (clearTimeout(_timer), _reject()), chain = (chain = chain.then(()=>new Promise((resolve, reject)=>{
-                _timer = setTimeout(resolve, 10), _reject = reject;
-            }))).then(rebuildAndContinue, rebuildAndContinue));
+        });
+        if (_timer) {
+            clearTimeout(_timer);
+            _reject();
+        }
+        // If a rebuild is already in progress we don't want to start another one until the 10ms timer has expired
+        chain = chain.then(()=>new Promise((resolve, reject)=>{
+                _timer = setTimeout(resolve, 10);
+                _reject = reject;
+            }));
+        // Resolves once this file has been rebuilt (or the rebuild for this file has failed)
+        // This queues as many rebuilds as there are changed files
+        // But those rebuilds happen after some delay
+        // And will immediately resolve if there are no changes
+        chain = chain.then(rebuildAndContinue, rebuildAndContinue);
+        return chain;
     }
-    return watcher.on("change", (file)=>recordChangedFile(file)), watcher.on("add", (file)=>recordChangedFile(file)), watcher.on("unlink", (file)=>{
-        file = (0, _normalizePath.default)(file), _micromatch.default.some([
+    watcher.on("change", (file)=>recordChangedFile(file));
+    watcher.on("add", (file)=>recordChangedFile(file));
+    // Restore watching any files that are "removed"
+    // This can happen when a file is pseudo-atomically replaced (a copy is created, overwritten, the old one is unlinked, and the new one is renamed)
+    // TODO: An an optimization we should allow removal when the config changes
+    watcher.on("unlink", (file)=>{
+        file = (0, _normalizepath.default)(file);
+        // Only re-add the file if it's not covered by a dynamic pattern
+        if (!_micromatch.default.some([
             file
-        ], state.contentPatterns.dynamic) || watcher.add(file);
-    }), watcher.on("raw", (evt, filePath, meta)=>{
-        if ("rename" !== evt) return;
+        ], state.contentPatterns.dynamic)) {
+            watcher.add(file);
+        }
+    });
+    // Some applications such as Visual Studio (but not VS Code)
+    // will only fire a rename event for atomic writes and not a change event
+    // This is very likely a chokidar bug but it's one we need to work around
+    // We treat this as a change event and rebuild the CSS
+    watcher.on("raw", (evt, filePath, meta)=>{
+        if (evt !== "rename") {
+            return;
+        }
         let watchedPath = meta.watchedPath;
-        filePath = watchedPath.endsWith(filePath) ? watchedPath : _path.default.join(watchedPath, filePath), !_micromatch.default.some([
+        // Watched path might be the file itself
+        // Or the directory it is in
+        filePath = watchedPath.endsWith(filePath) ? watchedPath : _path.default.join(watchedPath, filePath);
+        // Skip this event since the files it is for does not match any of the registered content globs
+        if (!_micromatch.default.some([
             filePath
-        ], state.contentPatterns.all) || pendingRebuilds.has(filePath) || (pendingRebuilds.add(filePath), (async function() {
+        ], state.contentPatterns.all)) {
+            return;
+        }
+        // Skip since we've already queued a rebuild for this file that hasn't happened yet
+        if (pendingRebuilds.has(filePath)) {
+            return;
+        }
+        // We'll go ahead and add the file to the pending rebuilds list here
+        // It'll be removed when the rebuild starts unless the read fails
+        // which will be taken care of as well
+        pendingRebuilds.add(filePath);
+        async function enqueue() {
             try {
-                let content = await (0, _utilsJs.readFileWithRetries)(_path.default.resolve(filePath));
-                if (void 0 === content) return;
-                await recordChangedFile(filePath, ()=>content, !0);
-            } catch  {}
-        })().then(()=>{
+                // We need to read the file as early as possible outside of the chain
+                // because it may be gone by the time we get to it. doing the read
+                // immediately increases the chance that the file is still there
+                let content = await (0, _utils.readFileWithRetries)(_path.default.resolve(filePath));
+                if (content === undefined) {
+                    return;
+                }
+                // This will push the rebuild onto the chain
+                // We MUST skip the rebuild check here otherwise the rebuild will never happen on Linux
+                // This is because the order of events and timing is different on Linux
+                // @ts-ignore: TypeScript isn't picking up that content is a string here
+                await recordChangedFile(filePath, ()=>content, true);
+            } catch  {
+            // If reading the file fails, it's was probably a deleted temporary file
+            // So we can ignore it and no rebuild is needed
+            }
+        }
+        enqueue().then(()=>{
+            // If the file read fails we still need to make sure the file isn't stuck in the pending rebuilds list
             pendingRebuilds.delete(filePath);
-        }));
-    }), {
+        });
+    });
+    return {
         fswatcher: watcher,
         refreshWatchedFiles () {
-            watcher.add(Array.from(state.contextDependencies)), watcher.add(Array.from(state.configBag.dependencies)), watcher.add(state.contentPatterns.all);
+            watcher.add(Array.from(state.contextDependencies));
+            watcher.add(Array.from(state.configBag.dependencies));
+            watcher.add(state.contentPatterns.all);
         }
     };
 }

package/lib/cli/help/index.js

@@ -1,28 +1,73 @@
+// @ts-check
 "use strict";
 Object.defineProperty(exports, "__esModule", {
-    value: !0
-}), Object.defineProperty(exports, "help", {
-    enumerable: !0,
-    get: ()=>help
+    value: true
 });
-const _packageJson = function(obj) {
+Object.defineProperty(exports, "help", {
+    enumerable: true,
+    get: function() {
+        return help;
+    }
+});
+const _packagejson = /*#__PURE__*/ _interop_require_default(require("../../../package.json"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
-}(require("../../../package.json"));
+}
 function help({ message , usage , commands , options  }) {
-    if (console.log(), console.log(`${_packageJson.default.name} v${_packageJson.default.version}`), message) for (let msg of (console.log(), message.split("\n")))console.log(msg);
-    if (usage && usage.length > 0) for (let example of (console.log(), console.log("Usage:"), usage))console.log(" ".repeat(2), example);
-    if (commands && commands.length > 0) for (let command of (console.log(), console.log("Commands:"), commands))console.log(" ".repeat(2), command);
+    let indent = 2;
+    // Render header
+    console.log();
+    console.log(`${_packagejson.default.name} v${_packagejson.default.version}`);
+    // Render message
+    if (message) {
+        console.log();
+        for (let msg of message.split("\n")){
+            console.log(msg);
+        }
+    }
+    // Render usage
+    if (usage && usage.length > 0) {
+        console.log();
+        console.log("Usage:");
+        for (let example of usage){
+            console.log(" ".repeat(indent), example);
+        }
+    }
+    // Render commands
+    if (commands && commands.length > 0) {
+        console.log();
+        console.log("Commands:");
+        for (let command of commands){
+            console.log(" ".repeat(indent), command);
+        }
+    }
+    // Render options
     if (options) {
         let groupedOptions = {};
-        for (let [key, value] of Object.entries(options))"object" == typeof value ? groupedOptions[key] = {
-            ...value,
-            flags: [
-                key
-            ]
-        } : groupedOptions[value].flags.push(key);
-        for (let { flags , description , deprecated  } of (console.log(), console.log("Options:"), Object.values(groupedOptions)))deprecated || (1 === flags.length ? console.log(" ".repeat(6), flags.slice().reverse().join(", ").padEnd(20, " "), description) : console.log(" ".repeat(2), flags.slice().reverse().join(", ").padEnd(24, " "), description));
+        for (let [key, value] of Object.entries(options)){
+            if (typeof value === "object") {
+                groupedOptions[key] = {
+                    ...value,
+                    flags: [
+                        key
+                    ]
+                };
+            } else {
+                groupedOptions[value].flags.push(key);
+            }
+        }
+        console.log();
+        console.log("Options:");
+        for (let { flags , description , deprecated  } of Object.values(groupedOptions)){
+            if (deprecated) continue;
+            if (flags.length === 1) {
+                console.log(" ".repeat(indent + 4 /* 4 = "-i, ".length */ ), flags.slice().reverse().join(", ").padEnd(20, " "), description);
+            } else {
+                console.log(" ".repeat(indent), flags.slice().reverse().join(", ").padEnd(24, " "), description);
+            }
+        }
     }
     console.log();
 }