tailwind-canonical 0.8.0 → 0.10.0

package/dist/cli/watch.js

@@ -1,33 +1,162 @@
-import { watch as fsWatch } from 'node:fs';
-import { dirname, resolve } from 'node:path';
+import { existsSync, watch as fsWatch, statSync, } from 'node:fs';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { DEFAULT_IGNORE } from '../core/scanner.js';
 import { errMsg, pluralize, timestamp } from './format.js';
-export function startWatch({ files, sink, processFile }) {
-    const fileSet = new Set(files);
-    const timers = new Map();
-    const dirs = new Set(files.map((file) => dirname(file)));
-    sink.log(`Watching ${pluralize(files.length, 'file')}... (Ctrl+C to stop)`);
-    for (const dir of dirs) {
-        fsWatch(dir, { recursive: true }, (_, filename) => {
-            if (!filename)
+function contains(root, path) {
+    const rel = relative(root, path);
+    return (rel === '' ||
+        (!isAbsolute(rel) && rel !== '..' && !rel.startsWith(`..${sep}`)));
+}
+/** Watch the existing ancestor of each target, including currently empty globs. */
+export function watchRoots(targets, configDirs, targetKinds) {
+    const dirs = [...configDirs];
+    for (const target of targets) {
+        if (target.startsWith('!'))
+            continue;
+        const kind = targetKinds?.get(target.replace(/\\/g, '/'));
+        const literal = kind ? kind === 'literal' : existsSync(target);
+        const magic = literal ? -1 : target.search(/[*?{[(]/);
+        const prefix = target.slice(0, magic);
+        let dir = magic < 0 ? target : prefix.endsWith(sep) ? prefix : dirname(prefix);
+        if (existsSync(dir) && !statSync(dir).isDirectory())
+            dir = dirname(dir);
+        while (!existsSync(dir)) {
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        dirs.push(dir);
+    }
+    const roots = [...new Set(dirs.map((dir) => resolve(dir)))];
+    return roots.filter((dir) => !roots.some((other) => other !== dir && contains(other, dir)));
+}
+export function startWatch({ files, roots, explicitTargets = [], sink, refresh, processFile, }) {
+    let fileSet = new Set(files);
+    const watchers = new Map();
+    const changed = new Set();
+    let timer;
+    let running = false;
+    let closed = false;
+    function close() {
+        if (closed)
+            return;
+        closed = true;
+        clearTimeout(timer);
+        changed.clear();
+        for (const watcher of watchers.values())
+            watcher.close();
+        watchers.clear();
+        process.removeListener('SIGINT', stop);
+        process.removeListener('SIGTERM', stop);
+    }
+    function stop() {
+        close();
+        sink.log('\nWatcher stopped.');
+    }
+    function fail(path, error) {
+        sink.error(`${timestamp()} ${path} — error: ${errMsg(error)}`);
+    }
+    function schedule() {
+        if (closed || running)
+            return;
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            void flush();
+        }, 50);
+    }
+    function synchronize(nextRoots) {
+        // Install replacements before closing the old set, so no event gap is added.
+        for (const root of nextRoots) {
+            if (watchers.has(root))
+                continue;
+            try {
+                const watcher = fsWatch(root, { recursive: true }, (_, filename) => {
+                    if (closed)
+                        return;
+                    const path = filename ? resolve(root, String(filename)) : root;
+                    const ignored = filename &&
+                        String(filename)
+                            .split(/[\\/]/)
+                            .some((part) => DEFAULT_IGNORE.includes(part));
+                    const explicitlyIncluded = explicitTargets.some((target) => contains(target, path) &&
+                        !relative(target, path)
+                            .split(/[\\/]/)
+                            .some((part) => DEFAULT_IGNORE.includes(part)));
+                    if (ignored && !explicitlyIncluded)
+                        return;
+                    changed.add(path);
+                    schedule();
+                });
+                watchers.set(root, watcher);
+                watcher.on('error', (error) => {
+                    if (closed)
+                        return;
+                    fail(root, error);
+                    process.exitCode = 1;
+                    close();
+                });
+            }
+            catch (error) {
+                fail(root, error);
+                process.exitCode = 1;
+                close();
+                return;
+            }
+        }
+        for (const [root, watcher] of watchers) {
+            if (!nextRoots.includes(root)) {
+                watcher.close();
+                watchers.delete(root);
+            }
+        }
+    }
+    async function flush() {
+        if (closed || running)
+            return;
+        running = true;
+        const batch = new Set(changed);
+        changed.clear();
+        try {
+            const next = await refresh(batch);
+            if (closed)
                 return;
-            const full = resolve(dir, filename);
-            if (!fileSet.has(full))
+            explicitTargets = next.explicitTargets ?? [];
+            synchronize(next.roots);
+            if (closed)
                 return;
-            clearTimeout(timers.get(full));
-            timers.set(full, setTimeout(() => {
-                timers.delete(full);
+            const nextFiles = new Set(next.files);
+            for (const file of nextFiles) {
+                if (closed)
+                    break;
+                if (!next.reprocessAll &&
+                    fileSet.has(file) &&
+                    ![...batch].some((path) => contains(path, file)))
+                    continue;
                 try {
-                    processFile(full);
+                    processFile(file);
                 }
                 catch (error) {
-                    sink.error(`${timestamp()} ${full} — error: ${errMsg(error)}`);
+                    fail(file, error);
                 }
-            }, 50));
-        });
+            }
+            fileSet = nextFiles;
+        }
+        catch (error) {
+            if (!closed)
+                fail('watch refresh', error);
+        }
+        finally {
+            running = false;
+            if (changed.size > 0)
+                schedule();
+        }
     }
-    process.once('SIGINT', () => {
-        sink.log('\nWatcher stopped.');
-        process.exit(0);
-    });
-    return { exitCode: 0, watching: true };
+    synchronize(roots);
+    if (!closed) {
+        process.once('SIGINT', stop);
+        process.once('SIGTERM', stop);
+        sink.log(`Watching ${pluralize(files.length, 'file')}... (Ctrl+C to stop)`);
+    }
+    return { exitCode: closed ? 1 : 0, watching: !closed, close };
 }

package/dist/core/class-strings.d.ts

@@ -2,6 +2,7 @@ export type ClassStringOpts = {
     functionNames?: string[];
     attributeNames?: string[];
     customTextTokens?: Record<number, string>;
+    tailwindVersion?: 3 | 4;
     isSuppressed?: (line: number) => boolean;
 };
 /** Builds the shared {functionNames, attributeNames} extraction options from a config. */
@@ -9,6 +10,7 @@ export declare function toClassStringOpts(config: {
     functionNames?: string[];
     attributeNames?: string[];
     customTextTokens?: Record<number, string>;
+    tailwindVersion?: 3 | 4;
 }): ClassStringOpts;
 export declare const SINGLE_CLASS_REGEX: RegExp;
 export declare function replaceClassStrings(content: string, transform: (s: string) => string, opts?: ClassStringOpts): {