tailwint 1.1.2 → 1.1.3

package/dist/index.js

@@ -11,8 +11,9 @@
 import { resolve, relative } from "path";
 import { readFileSync } from "fs";
 import { glob } from "glob";
-import { startServer, send, notify, shutdown, fileUri, langId, diagnosticsReceived, waitForProjectReady, waitForDiagnosticCount, resetState, } from "./lsp.js";
+import { startServer, send, notify, shutdown, fileUri, langId, diagnosticsReceived, settledProjects, brokenProjects, warnings, waitForAllProjects, resetState, } from "./lsp.js";
 import { fixFile } from "./edits.js";
+import { prescanCssFiles } from "./prescan.js";
 import { c, setTitle, windTrail, braille, windWave, dots, tick, advanceTick, startSpinner, progressBar, banner, fileBadge, diagLine, rainbowText, celebrationAnimation, } from "./ui.js";
 // Re-export for tests
 export { applyEdits } from "./edits.js";
@@ -85,9 +86,15 @@ export async function run(options = {}) {
     notify("initialized", {});
     stopBoot();
     console.error(`  ${c.green}\u2714${c.reset} ${c.dim}language server ready${c.reset} ${windTrail(30)}`);
-    // Open files — triggers the server's project discovery
+    // Pre-scan CSS files to predict project count
+    const prescan = prescanCssFiles(files);
+    // Open found files — triggers the server's project discovery
     const fileContents = new Map();
     const fileVersions = new Map();
+    const found = files.length;
+    const foundText = `sent ${found} file${found === 1 ? "" : "s"} to lsp`;
+    const foundPad = 54 - 2 - foundText.length - 1;
+    console.error(`  ${c.green}\u2714${c.reset} ${c.dim}${foundText}${c.reset} ${windTrail(foundPad)}`);
     for (const filePath of files) {
         let content;
         try {
@@ -107,27 +114,29 @@ export async function run(options = {}) {
             },
         });
     }
-    // Wait for project init + diagnostics — event-driven, no polling
-    setTitle("tailwint ~ initializing...");
-    const stopAnalyze = startSpinner(() => {
+    // Wait for all projects to be resolved (settled or broken)
+    setTitle("tailwint ~ scanning...");
+    const stopScan = startSpinner(() => {
         const received = diagnosticsReceived.size;
-        const label = received > 0 ? "analyzing" : "initializing";
-        setTitle(`tailwint ~ ${label} ${received}/${files.length}`);
-        const pct = Math.round((received / files.length) * 100);
+        const resolved = settledProjects + brokenProjects;
+        const label = received > 0 ? "scanning" : "initializing";
+        setTitle(`tailwint ~ ${label} ${resolved}/${prescan.maxProjects}`);
+        const pct = found > 0 ? Math.round((received / found) * 100) : 0;
         const bar = progressBar(pct, 18, true);
-        const totalStr = String(files.length);
+        const totalStr = String(found);
         const recvStr = String(received).padStart(totalStr.length);
-        const countText = `${recvStr}/${totalStr}`;
-        const usedCols = 2 + 1 + 1 + 20 + 1 + label.length + 3 + 1 + countText.length + 1;
-        const waveCols = Math.max(0, 56 - usedCols);
-        return `  ${braille()} ${bar} ${c.dim}${label}${dots()}${c.reset} ${c.bold}${recvStr}${c.reset}${c.dim}/${totalStr}${c.reset} ${windTrail(waveCols, tick)}`;
+        return `  ${braille()} ${bar} ${c.dim}${label}${dots()}${c.reset} ${c.bold}${recvStr}${c.reset}${c.dim}/${totalStr} scanned${c.reset} ${windTrail(12, tick)}`;
     }, 80);
-    await waitForProjectReady();
-    await waitForDiagnosticCount(files.length);
-    stopAnalyze();
-    const analyzedText = `${files.length} files analyzed`;
-    const analyzePad = 54 - 2 - analyzedText.length - 1;
-    console.error(`  ${c.green}\u2714${c.reset} ${c.dim}${analyzedText}${c.reset} ${windTrail(analyzePad)}`);
+    await waitForAllProjects(prescan.predictedRoots, prescan.maxProjects);
+    stopScan();
+    // Log warnings for broken projects
+    for (const w of warnings) {
+        console.error(`  ${c.yellow}\u26A0${c.reset} ${c.dim}${w}${c.reset}`);
+    }
+    const scanned = diagnosticsReceived.size;
+    const scannedText = `${scanned}/${found} files received`;
+    const scannedPad = 54 - 2 - scannedText.length - 1;
+    console.error(`  ${c.green}\u2714${c.reset} ${c.dim}${scannedText}${c.reset} ${windTrail(scannedPad)}`);
     console.error("");
     // Collect issues
     let totalIssues = 0;
@@ -149,13 +158,13 @@ export async function run(options = {}) {
         const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
         setTitle("tailwint \u2714 all clear");
         await celebrationAnimation();
-        console.error(`  ${c.green}\u2714${c.reset} ${c.bold}${files.length}${c.reset} files scanned ${c.dim}// ${rainbowText("all clear")} ${c.dim}${elapsed}s${c.reset}`);
+        console.error(`  ${c.green}\u2714${c.reset} ${c.bold}${scanned}${c.reset} files scanned ${c.dim}// ${rainbowText("all clear")} ${c.dim}${elapsed}s${c.reset}`);
         console.error("");
         await shutdown();
         return 0;
     }
     // Summary
-    console.error(`  ${c.bold}${c.white}${files.length}${c.reset} files scanned ${c.dim}//${c.reset} ${c.orange}${c.bold}${conflicts}${c.reset}${c.orange} conflicts${c.reset} ${c.dim}\u2502${c.reset} ${c.yellow}${c.bold}${canonical}${c.reset}${c.yellow} canonical${c.reset}`);
+    console.error(`  ${c.bold}${c.white}${scanned}${c.reset} files scanned ${c.dim}//${c.reset} ${c.orange}${c.bold}${conflicts}${c.reset}${c.orange} conflicts${c.reset} ${c.dim}\u2502${c.reset} ${c.yellow}${c.bold}${canonical}${c.reset}${c.yellow} canonical${c.reset}`);
     console.error("");
     // Report
     let fileNum = 0;

package/dist/lsp.d.ts

@@ -3,12 +3,22 @@
  */
 export declare const diagnosticsReceived: Map<string, any[]>;
 export declare let projectReady: boolean;
+/** Tracking for projectInitialized events */
+export declare let projectInitCount: number;
+export declare let settledProjects: number;
+export declare let brokenProjects: number;
+export declare const warnings: string[];
 /** Reset module state between runs (for programmatic multi-run usage). */
 export declare function resetState(): void;
-/** Returns a promise that resolves when @/tailwindCSS/projectInitialized fires. */
-export declare function waitForProjectReady(timeoutMs?: number): Promise<void>;
-/** Returns a promise that resolves when diagnosticsReceived.size >= count. */
-export declare function waitForDiagnosticCount(count: number, timeoutMs?: number): Promise<void>;
+/**
+ * Wait for all expected projects to be resolved (settled or broken).
+ *
+ * @param predictedRoots - Number of CSS files predicted to be project roots
+ * @param maxProjects - Upper bound (predictedRoots + predictedNonRoots)
+ * @param initTimeoutMs - How long to wait for each projectInitialized event
+ * @param debounceMs - Silence window to consider diagnostics "settled"
+ */
+export declare function waitForAllProjects(predictedRoots: number, maxProjects: number, initTimeoutMs?: number, debounceMs?: number): Promise<void>;
 /** Returns a promise that resolves when diagnostics are published for a specific URI. */
 export declare function waitForDiagnostic(uri: string, timeoutMs?: number): Promise<any[]>;
 export declare function startServer(root: string): void;

package/dist/lsp.js

@@ -61,12 +61,25 @@ const pending = new Map();
 export const diagnosticsReceived = new Map();
 export let projectReady = false;
 // ---------------------------------------------------------------------------
-// Event-driven waiters — resolved by processMessages, no polling
+// Project-aware wait state
 // ---------------------------------------------------------------------------
-let projectReadyResolve = null;
-let diagTarget = 0;
-let diagTargetResolve = null;
+/** Tracking for projectInitialized events */
+export let projectInitCount = 0;
+export let settledProjects = 0;
+export let brokenProjects = 0;
+let lastInitMs = 0;
+let inBrokenSequence = false;
+let awaitingFirstDiag = false;
+let currentProjectDiagCount = 0;
+export const warnings = [];
+/** Internal waiter state */
+let projectWaitResolve = null;
+let diagDebounceTimer = null;
+let projectInitTimer = null;
+let outerTimer = null;
 const diagWaiters = new Map();
+/** Config for the current wait */
+let waitConfig = { predictedRoots: 0, maxProjects: 0, initTimeoutMs: 5000, debounceMs: 500 };
 /** Reset module state between runs (for programmatic multi-run usage). */
 export function resetState() {
     msgId = 0;
@@ -76,38 +89,172 @@ export function resetState() {
     pending.clear();
     diagnosticsReceived.clear();
     projectReady = false;
-    projectReadyResolve = null;
-    diagTarget = 0;
-    diagTargetResolve = null;
+    projectInitCount = 0;
+    settledProjects = 0;
+    brokenProjects = 0;
+    lastInitMs = 0;
+    inBrokenSequence = false;
+    awaitingFirstDiag = false;
+    currentProjectDiagCount = 0;
+    warnings.length = 0;
+    projectWaitResolve = null;
+    if (diagDebounceTimer) {
+        clearTimeout(diagDebounceTimer);
+        diagDebounceTimer = null;
+    }
+    if (projectInitTimer) {
+        clearTimeout(projectInitTimer);
+        projectInitTimer = null;
+    }
+    if (outerTimer) {
+        clearTimeout(outerTimer);
+        outerTimer = null;
+    }
     diagWaiters.clear();
     vscodeSettings = null;
 }
-/** Returns a promise that resolves when @/tailwindCSS/projectInitialized fires. */
-export function waitForProjectReady(timeoutMs = 15_000) {
-    if (projectReady || serverDead)
-        return Promise.resolve();
-    return new Promise((res, rej) => {
-        projectReadyResolve = res;
-        const timer = setTimeout(() => {
-            projectReadyResolve = null;
-            res(); // resolve anyway — don't block forever
-        }, timeoutMs);
-        // Clean up timer if resolved early
-        const origRes = res;
-        projectReadyResolve = () => { clearTimeout(timer); origRes(); };
-    });
+function cleanupWaitTimers() {
+    if (diagDebounceTimer) {
+        clearTimeout(diagDebounceTimer);
+        diagDebounceTimer = null;
+    }
+    if (projectInitTimer) {
+        clearTimeout(projectInitTimer);
+        projectInitTimer = null;
+    }
+    if (outerTimer) {
+        clearTimeout(outerTimer);
+        outerTimer = null;
+    }
+}
+function finishWait() {
+    if (!projectWaitResolve)
+        return;
+    const resolve = projectWaitResolve;
+    projectWaitResolve = null;
+    cleanupWaitTimers();
+    resolve();
+}
+function isAllResolved() {
+    const resolved = settledProjects + brokenProjects;
+    return resolved >= waitConfig.maxProjects;
+}
+function startProjectInitTimeout() {
+    if (projectInitTimer)
+        clearTimeout(projectInitTimer);
+    projectInitTimer = setTimeout(() => {
+        // Timer fired — either no project init came, or we were waiting for
+        // more diagnostics after a single early one. If we got any diagnostics
+        // for the current project, settle it before finishing.
+        if (currentProjectDiagCount > 0 && !awaitingFirstDiag) {
+            settleCurrentProject();
+        }
+        else {
+            finishWait();
+        }
+    }, waitConfig.initTimeoutMs);
+}
+function onProjectInitialized() {
+    projectInitCount++;
+    const now = Date.now();
+    projectReady = true;
+    if (lastInitMs > 0 && (now - lastInitMs) < 500) {
+        // Rapid re-init — broken project
+        if (!inBrokenSequence) {
+            // First rapid init after a healthy one — the previous healthy init was actually broken
+            inBrokenSequence = true;
+            brokenProjects++;
+            warnings.push("A CSS file failed to initialize (likely an @apply referencing an unknown utility). " +
+                "That project's files will not receive diagnostics. " +
+                "See https://github.com/tailwindlabs/tailwindcss-intellisense/issues/1121");
+            // The previous init was counted as starting a healthy project's diagnostic wait.
+            // Cancel that wait — this project won't produce diagnostics.
+            if (diagDebounceTimer) {
+                clearTimeout(diagDebounceTimer);
+                diagDebounceTimer = null;
+            }
+        }
+        // Additional rapid inits for the same broken project — just update timestamp
+    }
+    else {
+        // Healthy init — new project starting
+        inBrokenSequence = false;
+        awaitingFirstDiag = true;
+        currentProjectDiagCount = 0;
+        // Cancel any pending project-init timeout since we just got a new one
+        if (projectInitTimer) {
+            clearTimeout(projectInitTimer);
+            projectInitTimer = null;
+        }
+        if (diagDebounceTimer) {
+            clearTimeout(diagDebounceTimer);
+            diagDebounceTimer = null;
+        }
+        // Don't start the diagnostic debounce yet — wait for the first diagnostic to arrive.
+        // Use the init timeout as the safety net (if no diagnostics arrive at all,
+        // this project is effectively broken even though it didn't rapid-fire).
+        startProjectInitTimeout();
+    }
+    lastInitMs = now;
+    // Check if broken projects pushed us to completion
+    if (isAllResolved()) {
+        finishWait();
+    }
+}
+function settleCurrentProject() {
+    settledProjects++;
+    if (isAllResolved()) {
+        finishWait();
+    }
+    else {
+        startProjectInitTimeout();
+    }
+}
+function startDiagDebounce() {
+    if (diagDebounceTimer)
+        clearTimeout(diagDebounceTimer);
+    // Cancel the init timeout — we're now in diagnostic-settling mode
+    if (projectInitTimer) {
+        clearTimeout(projectInitTimer);
+        projectInitTimer = null;
+    }
+    diagDebounceTimer = setTimeout(settleCurrentProject, waitConfig.debounceMs);
+}
+function onDiagnosticReceived() {
+    if (!projectWaitResolve)
+        return;
+    currentProjectDiagCount++;
+    if (awaitingFirstDiag) {
+        // First diagnostic after a healthy init — don't start the debounce yet.
+        // The first diagnostic is often just the CSS entry point, followed by a
+        // ~1s pause before the bulk TSX diagnostics arrive. Starting the debounce
+        // here would settle too early on large projects.
+        awaitingFirstDiag = false;
+    }
+    else if (currentProjectDiagCount >= 2) {
+        // Second diagnostic and beyond — the bulk is flowing, debounce is safe
+        startDiagDebounce();
+    }
 }
-/** Returns a promise that resolves when diagnosticsReceived.size >= count. */
-export function waitForDiagnosticCount(count, timeoutMs = 30_000) {
-    if (diagnosticsReceived.size >= count || serverDead)
+/**
+ * Wait for all expected projects to be resolved (settled or broken).
+ *
+ * @param predictedRoots - Number of CSS files predicted to be project roots
+ * @param maxProjects - Upper bound (predictedRoots + predictedNonRoots)
+ * @param initTimeoutMs - How long to wait for each projectInitialized event
+ * @param debounceMs - Silence window to consider diagnostics "settled"
+ */
+export function waitForAllProjects(predictedRoots, maxProjects, initTimeoutMs = 5_000, debounceMs = 500) {
+    if (serverDead || maxProjects === 0)
         return Promise.resolve();
+    waitConfig = { predictedRoots, maxProjects, initTimeoutMs, debounceMs };
     return new Promise((res) => {
-        diagTarget = count;
-        const timer = setTimeout(() => {
-            diagTargetResolve = null;
-            res();
-        }, timeoutMs);
-        diagTargetResolve = () => { clearTimeout(timer); res(); };
+        projectWaitResolve = res;
+        // Start waiting for first project init
+        startProjectInitTimeout();
+        // Hard outer timeout — never wait longer than this
+        const outerMs = initTimeoutMs + (maxProjects * 3000) + 5000;
+        outerTimer = setTimeout(finishWait, Math.min(outerMs, 30_000));
     });
 }
 /** Returns a promise that resolves when diagnostics are published for a specific URI. */
@@ -217,21 +364,12 @@ function processMessages() {
                 diagWaiters.delete(uri);
                 resolve(diags);
             }
-            // Resolve count-based waiter
-            if (diagTargetResolve && diagnosticsReceived.size >= diagTarget) {
-                const resolve = diagTargetResolve;
-                diagTargetResolve = null;
-                resolve();
-            }
+            // Notify the project-aware wait system
+            onDiagnosticReceived();
         }
         // Tailwind project initialized
         if (msg.method === "@/tailwindCSS/projectInitialized") {
-            projectReady = true;
-            if (projectReadyResolve) {
-                const resolve = projectReadyResolve;
-                projectReadyResolve = null;
-                resolve();
-            }
+            onProjectInitialized();
         }
     }
 }
@@ -249,18 +387,8 @@ function drainAll(reason) {
         p.reject(reason);
         pending.delete(id);
     }
-    // Resolve project-ready waiter (so run() doesn't hang)
-    if (projectReadyResolve) {
-        const r = projectReadyResolve;
-        projectReadyResolve = null;
-        r();
-    }
-    // Resolve count-based waiter
-    if (diagTargetResolve) {
-        const r = diagTargetResolve;
-        diagTargetResolve = null;
-        r();
-    }
+    // Resolve project wait (so run() doesn't hang)
+    finishWait();
     // Resolve all URI-specific waiters with empty arrays
     for (const [uri, r] of diagWaiters) {
         r([]);
@@ -323,7 +451,10 @@ export function notify(method, params) {
 export async function shutdown() {
     if (serverDead)
         return;
-    await send("shutdown", {}).catch(() => { });
+    await Promise.race([
+        send("shutdown", {}).catch(() => { }),
+        new Promise(r => setTimeout(r, 3000)),
+    ]);
     notify("exit", {});
     serverDead = true;
     try {

package/dist/prescan.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pre-scan CSS files to predict how many projects the language server will create.
+ *
+ * analyzeStylesheet() is adapted from tailwindlabs/tailwindcss-intellisense
+ * (packages/tailwindcss-language-server/src/version-guesser.ts, MIT licensed).
+ */
+type TailwindVersion = "3" | "4";
+export interface TailwindStylesheet {
+    root: boolean;
+    versions: TailwindVersion[];
+    explicitImport: boolean;
+}
+export declare function analyzeStylesheet(content: string): TailwindStylesheet;
+export interface PrescanResult {
+    /** Total CSS files found */
+    totalCssFiles: number;
+    /** CSS files predicted to be project roots */
+    predictedRoots: number;
+    /** CSS files that are Tailwind-related but not roots (could be promoted) */
+    predictedNonRoots: number;
+    /** CSS files with no Tailwind signals */
+    predictedUnrelated: number;
+    /** Upper bound on projects the server might create */
+    maxProjects: number;
+}
+export declare function prescanCssFiles(files: string[]): PrescanResult;
+export {};

package/dist/prescan.js

@@ -0,0 +1,76 @@
+/**
+ * Pre-scan CSS files to predict how many projects the language server will create.
+ *
+ * analyzeStylesheet() is adapted from tailwindlabs/tailwindcss-intellisense
+ * (packages/tailwindcss-language-server/src/version-guesser.ts, MIT licensed).
+ */
+import { readFileSync } from "fs";
+const HAS_V4_IMPORT = /@import\s*['"]tailwindcss(?:\/[^'"]+)?['"]/;
+const HAS_V4_DIRECTIVE = /@(theme|plugin|utility|custom-variant|variant|reference)\s*[^;{]+[;{]/;
+const HAS_V4_FN = /--(alpha|spacing|theme)\(/;
+const HAS_LEGACY_TAILWIND = /@tailwind\s*(base|preflight|components|variants|screens)+;/;
+const HAS_TAILWIND_UTILITIES = /@tailwind\s*utilities\s*[^;]*;/;
+const HAS_TAILWIND = /@tailwind\s*[^;]+;/;
+const HAS_COMMON_DIRECTIVE = /@(config|apply)\s*[^;{]+[;{]/;
+const HAS_NON_URL_IMPORT = /@import\s*['"](?!([a-z]+:|\/\/))/;
+export function analyzeStylesheet(content) {
+    if (HAS_V4_IMPORT.test(content)) {
+        return { root: true, versions: ["4"], explicitImport: true };
+    }
+    if (HAS_V4_DIRECTIVE.test(content)) {
+        if (HAS_TAILWIND_UTILITIES.test(content)) {
+            return { root: true, versions: ["4"], explicitImport: false };
+        }
+        return { root: false, versions: ["4"], explicitImport: false };
+    }
+    if (HAS_V4_FN.test(content)) {
+        return { root: false, versions: ["4"], explicitImport: false };
+    }
+    if (HAS_LEGACY_TAILWIND.test(content)) {
+        return { root: false, versions: ["3"], explicitImport: false };
+    }
+    if (HAS_TAILWIND.test(content)) {
+        return { root: true, versions: ["4", "3"], explicitImport: false };
+    }
+    if (HAS_COMMON_DIRECTIVE.test(content)) {
+        return { root: false, versions: ["4", "3"], explicitImport: false };
+    }
+    if (HAS_NON_URL_IMPORT.test(content)) {
+        return { root: true, versions: ["4", "3"], explicitImport: false };
+    }
+    return { root: false, versions: [], explicitImport: false };
+}
+export function prescanCssFiles(files) {
+    let predictedRoots = 0;
+    let predictedNonRoots = 0;
+    let predictedUnrelated = 0;
+    for (const filePath of files) {
+        if (!filePath.endsWith(".css"))
+            continue;
+        let content;
+        try {
+            content = readFileSync(filePath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const result = analyzeStylesheet(content);
+        if (result.versions.length === 0) {
+            predictedUnrelated++;
+        }
+        else if (result.root) {
+            predictedRoots++;
+        }
+        else {
+            predictedNonRoots++;
+        }
+    }
+    const totalCssFiles = predictedRoots + predictedNonRoots + predictedUnrelated;
+    return {
+        totalCssFiles,
+        predictedRoots,
+        predictedNonRoots,
+        predictedUnrelated,
+        maxProjects: predictedRoots + predictedNonRoots,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tailwint",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Tailwind CSS linter for CI — drives the official language server to catch class issues and auto-fix them",
   "license": "MIT",
   "author": "Peter Wang",