rainbowindex 0.6.0 → 0.7.0

package/dist/theme-CIZiGlce.d.ts

@@ -0,0 +1,115 @@
+import { E as EditorSession } from './session-CMaskdB7.js';
+
+/**
+ * Two lint rules over the editor API, in the shape both Oxlint and ESLint read.
+ *
+ * Neither rule walks the AST for class positions, and that is deliberate. The
+ * scanner already decides what a class position is — a `class`/`className`
+ * attribute, an argument to a class helper, a `cva`/`tv` config, a safelist —
+ * and a rule that re-derived that from the AST would drift from the compiler
+ * it is supposed to be describing. So both rules run once per file over the
+ * source text, take the scanner's own candidates with their exact spans, and
+ * report on those. A class the build compiles and a class the linter checks are
+ * then the same set by construction.
+ *
+ * The rule objects use only the slice of the linter API the two hosts share:
+ * `create(context)`, `context.report({ message, node, loc })`, and a visitor
+ * keyed by node type. ESLint suggestions are attached where the host supports
+ * them, and ignored where it does not.
+ */
+interface LintPosition {
+    line: number;
+    column: number;
+}
+interface LintLoc {
+    start: LintPosition;
+    end: LintPosition;
+}
+interface LintFix {
+    range: [number, number];
+    text: string;
+}
+interface LintFixer {
+    replaceTextRange(range: [number, number], text: string): LintFix;
+}
+interface LintSuggestion {
+    desc: string;
+    fix(fixer: LintFixer): LintFix;
+}
+interface LintReport {
+    message: string;
+    node?: unknown;
+    loc?: LintLoc;
+    suggest?: LintSuggestion[];
+}
+interface LintSourceCode {
+    getText(): string;
+    getLocFromIndex(index: number): LintPosition;
+}
+interface LintContext {
+    report(report: LintReport): void;
+    /** ESLint ≥ 8.40 and Oxlint both expose this; older ESLint used a getter. */
+    sourceCode?: LintSourceCode;
+    getSourceCode?(): LintSourceCode;
+    filename?: string;
+    getFilename?(): string;
+    options?: readonly unknown[];
+    cwd?: string;
+}
+/** Node type → handler. A rule with nothing to do returns an empty one. */
+type LintVisitor = Partial<Record<string, (node: unknown) => void>>;
+interface LintRule {
+    meta: {
+        type: "problem" | "suggestion";
+        docs: {
+            description: string;
+        };
+        hasSuggestions?: boolean;
+        schema?: readonly unknown[];
+    };
+    create(context: LintContext): LintVisitor;
+}
+declare const noUnknownClassRule: LintRule;
+declare const noConflictingClassesRule: LintRule;
+/** The rules both entry points expose, under the names both hosts use. */
+declare const rules: Readonly<Record<string, LintRule>>;
+
+/**
+ * Finding a project's theme from inside a linter.
+ *
+ * A lint rule that knows what a class *means* needs the compiled theme, and a
+ * linter gives it no build context — just a file and a working directory. So
+ * this locates the CSS entry the way the editor toolkit does (the same
+ * candidate list, the same activation test), reads it with the same `@import`
+ * inliner a build uses, and hands back an `EditorSession`.
+ *
+ * One session is cached per resolved entry, because a lint run calls into it
+ * once per file and rebuilding the theme each time would dominate the run. The
+ * cache is invalidated by mtime — on the entry and on every file it imports —
+ * so a watching linter picks up a token change without a restart.
+ */
+
+interface ThemeSourceOptions {
+    /**
+     * The project's CSS entry, absolute or relative to `cwd`. Set it when the
+     * entry is somewhere the candidate list does not look, or to skip the
+     * search entirely.
+     */
+    css?: string;
+    /** Where the search starts. Defaults to the linter's working directory. */
+    cwd?: string;
+}
+/** The entry the candidate search settled on, or null when there is none. */
+declare function findCSSEntry(cwd: string): string | null;
+/**
+ * The session for a project, or null when no Rainbow Index entry was found.
+ *
+ * Returning null rather than throwing is the point: a rule that cannot find a
+ * theme has nothing to say, and a linter run over a repository that does not
+ * use Rainbow Index must stay silent rather than fail.
+ */
+declare function getSession(options?: ThemeSourceOptions): EditorSession | null;
+/** Drop every cached session. For tests, and for a host that knows better. */
+declare function clearSessionCache(): void;
+
+export { type LintRule as L, type ThemeSourceOptions as T, type LintContext as a, type LintFix as b, type LintFixer as c, type LintLoc as d, type LintReport as e, type LintSourceCode as f, type LintSuggestion as g, type LintVisitor as h, clearSessionCache as i, findCSSEntry as j, getSession as k, noUnknownClassRule as l, noConflictingClassesRule as n, rules as r };

package/dist/vite.d.ts

@@ -1,5 +1,14 @@
 import { Plugin } from 'vite';
 
-declare function rainbowindexVite(): Plugin;
+/**
+ * A pair, because the two halves need opposite ends of Vite's pipeline.
+ *
+ * `rainbowindex` runs `pre`: it has to read a CSS entry before Vite inlines its
+ * `@import` at-rules. `rainbowindex:snapshot` runs `post`: it has to prepend an
+ * import to real JavaScript, after every framework compiler has turned a
+ * component into some. Vite flattens a returned array, so `plugins:
+ * [rainbowindex()]` is unchanged for the caller.
+ */
+declare function rainbowindexVite(): Plugin[];
 
 export { rainbowindexVite as default };

package/dist/vite.mjs

@@ -1,31 +1,41 @@
 import {
   postcss_default
-} from "./chunk-3LWJTLOJ.mjs";
+} from "./chunk-RC6DDE4L.mjs";
+import {
+  snapshotFromCSS
+} from "./chunk-6OORICWF.mjs";
 import {
   disableScanChangeTracking,
   enableScanChangeTracking,
   enableSourceFileListCache,
   invalidateSourceFileListCache,
   markSourceFileChanged
-} from "./chunk-WK6S4HTC.mjs";
+} from "./chunk-2T7V5XLK.mjs";
+import {
+  createNodeImportResolver
+} from "./chunk-W756NVYI.mjs";
 import {
   isSourceFile
-} from "./chunk-3HRMFZGE.mjs";
+} from "./chunk-X66Z2YHT.mjs";
 import {
   DIRECTIVE_TYPE_NAMES,
   codepointCompare,
-  expandApplyGroups,
+  expandGroupsInStylesheet,
   extractClassesFromSource,
   findClosingBrace,
   hasRIActivation,
+  inlineDirectiveImports,
   isAtRuleBoundary,
   isAtRuleNameChar,
   parseFileDisables,
+  scanEntries,
+  stripCSSComments,
   warningCode
-} from "./chunk-KSNYSR3C.mjs";
+} from "./chunk-FJOZJIKB.mjs";
+import "./chunk-L56IRO7A.mjs";
 import {
   devWarn
-} from "./chunk-6U4IOFOS.mjs";
+} from "./chunk-XQGSG2HK.mjs";
 
 // src/integrations/vite.ts
 import { existsSync } from "fs";
@@ -151,9 +161,72 @@ function rewriteDirectiveBodies(code) {
   if (last === 0) return code;
   return out + code.slice(last);
 }
+var BLOCK_AFTER_DECLARATION_DIRECTIVES = /* @__PURE__ */ new Set([
+  "font",
+  "animate",
+  "color"
+]);
+var LEGACY_APPLY_GROUP_RE = /@a(?:pply)?\b[^;{}]*[\w@-]+:\{/;
+function usesLegacyDirectiveSyntax(code) {
+  if (LEGACY_APPLY_GROUP_RE.test(code)) return true;
+  let i = 0;
+  while (i < code.length) {
+    const at = code.indexOf("@", i);
+    if (at === -1) return false;
+    if (!isAtRuleBoundary(code, at)) {
+      i = at + 1;
+      continue;
+    }
+    let nameEnd = at + 1;
+    while (nameEnd < code.length && isAtRuleNameChar(code.charCodeAt(nameEnd))) nameEnd++;
+    const name = code.slice(at + 1, nameEnd);
+    const removals = REMOVAL_BODY_DIRECTIVES.has(name);
+    const keywords = KEYWORD_BODY_DIRECTIVES.has(name);
+    const blocks = BLOCK_AFTER_DECLARATION_DIRECTIVES.has(name);
+    if (!removals && !keywords && !blocks) {
+      i = nameEnd;
+      continue;
+    }
+    let braceIdx = nameEnd;
+    while (braceIdx < code.length) {
+      const ch = code[braceIdx];
+      if (ch === "{" || ch === ";" || ch === "}") break;
+      braceIdx++;
+    }
+    if (code[braceIdx] !== "{") {
+      i = braceIdx + 1;
+      continue;
+    }
+    const close = findClosingBrace(code, braceIdx);
+    if (close === -1) return true;
+    const body = code.slice(braceIdx + 1, close);
+    if (removals && matches(REMOVAL_RE, stripBlocks(body))) return true;
+    if (keywords && matches(FLUID_KEYWORD_RE, stripBlocks(body))) return true;
+    if (name === "color" && matches(COLOR_FLAG_RE, body)) return true;
+    if (blocks) {
+      for (const entry of scanEntries(stripCSSComments(body), {
+        newlineTerminates: name !== "animate"
+      })) {
+        if (entry.key !== "" && entry.value !== "" && entry.block !== void 0) return true;
+      }
+    }
+    i = close + 1;
+  }
+  return false;
+}
+function matches(pattern, text) {
+  pattern.lastIndex = 0;
+  return pattern.test(text);
+}
+function stripBlocks(body) {
+  return mapTopLevelSpans(body, keepSpan, (interior) => " ".repeat(interior.length));
+}
 
 // src/integrations/vite.ts
 var CSS_FILE_RE = /\.(?:module\.)?css$/;
+var SNAPSHOT_ID = "virtual:rainbowindex/snapshot";
+var RESOLVED_SNAPSHOT_ID = `\0${SNAPSHOT_ID}`;
+var RI_IMPORT_RE = /from\s*["']rainbowindex["']/;
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
 var POSTCSS_CONFIG_FILES = [
   "postcss.config.js",
@@ -171,134 +244,200 @@ function rainbowindexVite() {
   let root = process.cwd();
   let logger;
   const riCSSFiles = /* @__PURE__ */ new Set();
+  const riCSSSources = /* @__PURE__ */ new Map();
+  let devServer;
   const fileVersions = /* @__PURE__ */ new Map();
   const candidateSignatures = /* @__PURE__ */ new Map();
   let hotUpdateCount = 0;
   const PRUNE_INTERVAL = 50;
-  return {
-    name: "rainbowindex",
-    enforce: "pre",
-    async config(config) {
-      root = config.root ?? process.cwd();
-      const patch = {};
-      const ignorePatterns = await riStylesheetPatterns(root);
-      if (ignorePatterns.length > 0) {
-        patch.fmt = { ignorePatterns };
-      }
-      if (!hasLocalPostCSSConfig(root)) {
-        patch.css = {
-          postcss: {
-            plugins: [postcss_default()]
-          }
-        };
-      }
-      return patch;
-    },
-    configureServer(server) {
-      root = server.config?.root ?? process.cwd();
-      enableSourceFileListCache();
-      server.watcher?.on("add", invalidateSourceFileListCache);
-      server.watcher?.on("unlink", invalidateSourceFileListCache);
-      server.watcher?.on("unlinkDir", invalidateSourceFileListCache);
-      server.httpServer?.once("close", invalidateSourceFileListCache);
-      enableScanChangeTracking();
-      server.watcher?.on("change", (file) => markSourceFileChanged(file));
-      server.httpServer?.once("close", disableScanChangeTracking);
-      logger = {
-        info: (msg) => server.config.logger?.info?.(msg, { timestamp: true }),
-        warn: (msg) => server.config.logger?.warn?.(msg, { timestamp: true })
+  const injectSnapshot = {
+    name: "rainbowindex:snapshot",
+    enforce: "post",
+    transform(code, id) {
+      if (id === RESOLVED_SNAPSHOT_ID || !RI_IMPORT_RE.test(code)) return null;
+      return {
+        code: `import ${JSON.stringify(SNAPSHOT_ID)};${code}`,
+        map: { mappings: "" }
       };
-      if (hasLocalPostCSSConfig(root)) {
-        logger.info("[rainbowindex] Using local PostCSS config \u2014 skipped auto-injection.");
-      } else {
-        logger.info("[rainbowindex] Injected PostCSS plugin (no local postcss.config.* found).");
-      }
-      server.httpServer?.once("listening", async () => {
-        const cssFiles = [];
-        const fileMap = server.moduleGraph.fileToModulesMap;
-        if (fileMap) {
-          for (const [file] of fileMap) {
-            if (CSS_FILE_RE.test(file)) {
-              cssFiles.push(file);
+    }
+  };
+  return [
+    {
+      name: "rainbowindex",
+      enforce: "pre",
+      async config(config) {
+        root = config.root ?? process.cwd();
+        const patch = {};
+        const ignorePatterns = await riStylesheetPatterns(root);
+        if (ignorePatterns.length > 0) {
+          patch.fmt = { ignorePatterns };
+        }
+        if (!hasLocalPostCSSConfig(root)) {
+          patch.css = {
+            postcss: {
+              plugins: [postcss_default()]
             }
+          };
+        }
+        return patch;
+      },
+      configureServer(server) {
+        root = server.config?.root ?? process.cwd();
+        devServer = server;
+        enableSourceFileListCache();
+        server.watcher?.on("add", invalidateSourceFileListCache);
+        server.watcher?.on("unlink", invalidateSourceFileListCache);
+        server.watcher?.on("unlinkDir", invalidateSourceFileListCache);
+        server.httpServer?.once("close", invalidateSourceFileListCache);
+        enableScanChangeTracking();
+        server.watcher?.on("change", (file) => markSourceFileChanged(file));
+        server.httpServer?.once("close", disableScanChangeTracking);
+        logger = {
+          info: (msg) => server.config.logger?.info?.(msg, { timestamp: true }),
+          warn: (msg) => server.config.logger?.warn?.(msg, { timestamp: true })
+        };
+        if (hasLocalPostCSSConfig(root)) {
+          logger.info("[rainbowindex] Using local PostCSS config \u2014 skipped auto-injection.");
+        } else {
+          logger.info("[rainbowindex] Injected PostCSS plugin (no local postcss.config.* found).");
+        }
+        server.httpServer?.once("listening", async () => {
+          const cssFiles = [];
+          const fileMap = server.moduleGraph.fileToModulesMap;
+          if (fileMap) {
+            for (const [file] of fileMap) {
+              if (CSS_FILE_RE.test(file)) {
+                cssFiles.push(file);
+              }
+            }
+          }
+          if (cssFiles.length === 0) {
+            const diskCSS = await findCSSFilesOnDisk(root);
+            cssFiles.push(...diskCSS);
+          }
+          await Promise.all(cssFiles.map((file) => checkCSSFileAsync(file)));
+          if (riCSSFiles.size === 0) {
+            logger?.warn(
+              `[RI-1602] rainbowindex Vite plugin is registered but no CSS entry with \`@import "rainbowindex"\` was found under ${root}. Create one (e.g. src/index.css) and import it from your app entry, then restart the dev server. Or run \`rainbowindex init\` to wire it up automatically.`
+            );
+          } else {
+            const list = [...riCSSFiles].map((f) => relative(root, f).replaceAll("\\", "/")).join(", ");
+            logger?.info(`[rainbowindex] CSS entries: ${list}`);
+          }
+        });
+      },
+      resolveId(id) {
+        return id === SNAPSHOT_ID ? RESOLVED_SNAPSHOT_ID : null;
+      },
+      async load(id) {
+        if (id !== RESOLVED_SNAPSHOT_ID) return null;
+        if (riCSSSources.size === 0) await seedCSSSourcesFromDisk();
+        const snapshot = buildClientSnapshot();
+        return `import { hydrateSnapshot, publishSnapshot } from "rainbowindex";
+publishSnapshot(hydrateSnapshot(${JSON.stringify(snapshot)}));
+if (import.meta.hot) import.meta.hot.accept();
+`;
+      },
+      transform(code, id) {
+        const file = id.split("?")[0];
+        if (CSS_FILE_RE.test(file)) {
+          fileVersions.set(file, (fileVersions.get(file) ?? 0) + 1);
+          if (hasRIActivation(code)) {
+            riCSSFiles.add(file);
+            if (riCSSSources.get(file) !== code) {
+              riCSSSources.set(file, code);
+              invalidateClientSnapshot();
+            }
+            let safe = rewriteDirectiveBodies(code);
+            const expandWarnings = [];
+            safe = expandGroupsInStylesheet(safe, expandWarnings, file);
+            const suppressed = parseFileDisables(code);
+            for (const w of expandWarnings) {
+              const warned = warningCode(w);
+              if (warned !== null && suppressed.has(warned)) continue;
+              (logger?.warn ?? console.warn)(`[rainbowindex] ${w}`);
+            }
+            return safe !== code ? safe : null;
           }
+          riCSSFiles.delete(file);
+          if (riCSSSources.delete(file)) invalidateClientSnapshot();
         }
-        if (cssFiles.length === 0) {
-          const diskCSS = await findCSSFilesOnDisk(root);
-          cssFiles.push(...diskCSS);
+        return null;
+      },
+      async handleHotUpdate(ctx) {
+        const { file, server, modules } = ctx;
+        if (++hotUpdateCount % PRUNE_INTERVAL === 0) {
+          await pruneDeletedFiles();
         }
-        await Promise.all(cssFiles.map((file) => checkCSSFileAsync(file)));
-        if (riCSSFiles.size === 0) {
-          logger?.warn(
-            `[RI-1602] rainbowindex Vite plugin is registered but no CSS entry with \`@import "rainbowindex"\` was found under ${root}. Create one (e.g. src/index.css) and import it from your app entry, then restart the dev server. Or run \`rainbowindex init\` to wire it up automatically.`
-          );
-        } else {
-          const list = [...riCSSFiles].map((f) => relative(root, f).replaceAll("\\", "/")).join(", ");
-          logger?.info(`[rainbowindex] CSS entries: ${list}`);
+        if (CSS_FILE_RE.test(file)) {
+          await checkCSSFileAsync(file);
+          return;
         }
-      });
-    },
-    transform(code, id) {
-      const file = id.split("?")[0];
-      if (CSS_FILE_RE.test(file)) {
-        fileVersions.set(file, (fileVersions.get(file) ?? 0) + 1);
-        if (hasRIActivation(code)) {
-          riCSSFiles.add(file);
-          let safe = rewriteDirectiveBodies(code);
-          const expandWarnings = [];
-          safe = expandApplyGroups(safe, expandWarnings, file);
-          const suppressed = parseFileDisables(code);
-          for (const w of expandWarnings) {
-            const warned = warningCode(w);
-            if (warned !== null && suppressed.has(warned)) continue;
-            (logger?.warn ?? console.warn)(`[rainbowindex] ${w}`);
+        if (!isSourceFile(file)) return;
+        markSourceFileChanged(file);
+        const previous = candidateSignatures.get(file);
+        let signature;
+        try {
+          const content = await ctx.read();
+          signature = [...extractClassesFromSource({ path: file, content })].sort(codepointCompare).join(" ");
+        } catch {
+          candidateSignatures.delete(file);
+        }
+        if (signature !== void 0) {
+          candidateSignatures.set(file, signature);
+          if (previous === signature) return;
+        }
+        const extraModules = [];
+        const hmrModules = new Set(modules);
+        for (const cssFile of riCSSFiles) {
+          const mods = server.moduleGraph.getModulesByFile(cssFile);
+          if (mods) {
+            for (const mod of mods) {
+              if (!hmrModules.has(mod)) {
+                extraModules.push(mod);
+              }
+            }
           }
-          return safe !== code ? safe : null;
         }
-        riCSSFiles.delete(file);
+        if (extraModules.length > 0) {
+          return [...modules, ...extraModules];
+        }
       }
-      return null;
     },
-    async handleHotUpdate(ctx) {
-      const { file, server, modules } = ctx;
-      if (++hotUpdateCount % PRUNE_INTERVAL === 0) {
-        await pruneDeletedFiles();
-      }
-      if (CSS_FILE_RE.test(file)) {
-        await checkCSSFileAsync(file);
-        return;
-      }
-      if (!isSourceFile(file)) return;
-      markSourceFileChanged(file);
-      const previous = candidateSignatures.get(file);
-      let signature;
+    injectSnapshot
+  ];
+  async function seedCSSSourcesFromDisk() {
+    const files = await findCSSFilesOnDisk(root);
+    await Promise.all(
+      files.map(async (file) => {
+        try {
+          const content = await readFile(file, "utf-8");
+          if (!hasRIActivation(content)) return;
+          riCSSFiles.add(file);
+          riCSSSources.set(file, content);
+        } catch {
+        }
+      })
+    );
+  }
+  function buildClientSnapshot() {
+    const resolveImport = createNodeImportResolver({ cwd: root });
+    const css = [...riCSSSources.keys()].sort(codepointCompare).map((file) => {
+      const text = riCSSSources.get(file) ?? "";
       try {
-        const content = await ctx.read();
-        signature = [...extractClassesFromSource({ path: file, content })].sort(codepointCompare).join(" ");
+        return inlineDirectiveImports(text, { resolve: resolveImport, from: file }).css;
       } catch {
-        candidateSignatures.delete(file);
+        return text;
       }
-      if (signature !== void 0) {
-        candidateSignatures.set(file, signature);
-        if (previous === signature) return;
-      }
-      const extraModules = [];
-      const hmrModules = new Set(modules);
-      for (const cssFile of riCSSFiles) {
-        const mods = server.moduleGraph.getModulesByFile(cssFile);
-        if (mods) {
-          for (const mod of mods) {
-            if (!hmrModules.has(mod)) {
-              extraModules.push(mod);
-            }
-          }
-        }
-      }
-      if (extraModules.length > 0) {
-        return [...modules, ...extraModules];
-      }
-    }
-  };
+    }).join("\n");
+    return snapshotFromCSS(css);
+  }
+  function invalidateClientSnapshot() {
+    const graph = devServer?.moduleGraph;
+    if (!graph) return;
+    const mod = graph.getModuleById(RESOLVED_SNAPSHOT_ID);
+    if (mod) graph.invalidateModule(mod);
+  }
   async function pruneDeletedFiles() {
     const tracked = /* @__PURE__ */ new Set([...riCSSFiles, ...fileVersions.keys(), ...candidateSignatures.keys()]);
     const checks = [...tracked].map(async (file) => {
@@ -306,6 +445,7 @@ function rainbowindexVite() {
         await access(file);
       } catch {
         riCSSFiles.delete(file);
+        if (riCSSSources.delete(file)) invalidateClientSnapshot();
         fileVersions.delete(file);
         candidateSignatures.delete(file);
       }
@@ -337,7 +477,9 @@ function rainbowindexVite() {
     const active = await Promise.all(
       files.map(async (file) => {
         try {
-          return hasRIActivation(await readFile(file, "utf-8")) ? file : null;
+          const code = await readFile(file, "utf-8");
+          if (!hasRIActivation(code)) return null;
+          return usesLegacyDirectiveSyntax(code) ? file : null;
         } catch {
           return null;
         }
@@ -357,12 +499,18 @@ function rainbowindexVite() {
       if ((fileVersions.get(file) ?? 0) !== versionBefore) return;
       if (hasRIActivation(raw)) {
         riCSSFiles.add(file);
+        if (riCSSSources.get(file) !== raw) {
+          riCSSSources.set(file, raw);
+          invalidateClientSnapshot();
+        }
       } else {
         riCSSFiles.delete(file);
+        if (riCSSSources.delete(file)) invalidateClientSnapshot();
       }
     } catch (_err) {
       if ((fileVersions.get(file) ?? 0) !== versionBefore) return;
       riCSSFiles.delete(file);
+      if (riCSSSources.delete(file)) invalidateClientSnapshot();
     }
   }
 }