rainbowindex 0.5.1 → 0.7.0

package/dist/{chunk-4CTJLMYM.mjs → chunk-RC6DDE4L.mjs}

@@ -1,16 +1,17 @@
 import {
   compileScannedProject
-} from "./chunk-F4VCBISU.mjs";
+} from "./chunk-2T7V5XLK.mjs";
 import {
   APPLY_ALIASES,
   DIRECTIVE_NAMES_SET,
   MAX_DIRECTIVE_INPUT_SIZE,
   RI_IMPORT_SPECIFIER_ALTERNATION,
   applyVariantWrappers,
+  checkAppliedFontWeights,
   compileCSSFunctions,
   computeSortKey,
-  expandVariantGroups,
-  forEachApplyClass,
+  expandApplyBodyGroups,
+  forEachApplyClassList,
   hasApplyLikeDirective,
   hasCSSFunctions,
   hasRIActivation,
@@ -20,7 +21,7 @@ import {
   resolveUtilityDeclarations,
   resolveVariant,
   splitSelectorList
-} from "./chunk-PDORZSQX.mjs";
+} from "./chunk-FJOZJIKB.mjs";
 
 // src/integrations/postcss/index.ts
 import postcss2 from "postcss";
@@ -95,7 +96,7 @@ function resolveFullNestingSelector(rule) {
   }
   return composeNestedSelectors(parts);
 }
-function processApply(root, theme, warnings) {
+function processApply(root, theme, warnings, cssPath) {
   for (const alias of APPLY_ALIASES) {
     root.walkAtRules(alias, (atRule) => {
       atRule.name = "apply";
@@ -117,7 +118,7 @@ function processApply(root, theme, warnings) {
     const groupRoots = /* @__PURE__ */ new Set();
     root.walkAtRules("apply", (atRule) => {
       applyNodes.push(atRule);
-      const params = expandVariantGroups(atRule.params, warnings);
+      const params = expandApplyBodyGroups(atRule.params, warnings, cssPath);
       const classNames = params.trim().split(/\s+/).filter(Boolean);
       classListByNode.set(atRule, classNames);
       if (classNames.includes("group")) {
@@ -174,6 +175,7 @@ function expandApply(atRule, classNames, theme, warnings, customVariantMap, grou
     atRule.remove();
     return;
   }
+  checkAppliedFontWeights(classNames, theme, warnings);
   const resolved = [];
   for (const className of classNames) {
     let entry = resolveCache.get(className);
@@ -313,9 +315,7 @@ function expandApply(atRule, classNames, theme, warnings, customVariantMap, grou
         bucket.nestedSelector,
         bucket.nestedBlocks
       );
-      if (node) {
-        docRoot().append(node);
-      }
+      for (const branch of node) docRoot().append(branch);
     } else if (hasGroupVariants) {
       const node = buildVariantNode(
         fullNestingSelector(),
@@ -325,9 +325,7 @@ function expandApply(atRule, classNames, theme, warnings, customVariantMap, grou
         bucket.nestedSelector,
         bucket.nestedBlocks
       );
-      if (node) {
-        docRoot().append(node);
-      }
+      for (const branch of node) docRoot().append(branch);
     } else {
       const node = buildVariantNode(
         baseSelector,
@@ -337,9 +335,9 @@ function expandApply(atRule, classNames, theme, warnings, customVariantMap, grou
         bucket.nestedSelector,
         bucket.nestedBlocks
       );
-      if (node) {
-        parentContainer.insertAfter(insertAfter, node);
-        insertAfter = node;
+      for (const branch of node) {
+        parentContainer.insertAfter(insertAfter, branch);
+        insertAfter = branch;
       }
     }
   }
@@ -374,7 +372,10 @@ function findCustomUtility(utility, value, negative, theme) {
 function checkCustomApplyWarnings(cu, theme, warnings, visiting = /* @__PURE__ */ new Set()) {
   if (!hasApplyLikeDirective(cu.body)) return;
   const innerClasses = [];
-  forEachApplyClass(cu.body, (cls) => innerClasses.push(cls));
+  forEachApplyClassList(cu.body, (classes) => {
+    checkAppliedFontWeights(classes, theme, warnings);
+    innerClasses.push(...classes);
+  });
   if (innerClasses.length === 0) return;
   if (visiting.has(cu.name)) {
     warnings.push(
@@ -470,8 +471,20 @@ function buildNestedBlockNode(block, sourceNode, important) {
   return node;
 }
 function buildVariantNode(baseSelector, wrappers, decls, sourceNode, nestedSelector, nestedBlocks) {
-  if (decls.length === 0 && nestedBlocks.length === 0) return null;
-  const { selector, atRules, startingStyle } = applyVariantWrappers(baseSelector, wrappers);
+  if (decls.length === 0 && nestedBlocks.length === 0) return [];
+  return applyVariantWrappers(baseSelector, wrappers).map(
+    ({ selector, atRules, startingStyle }) => buildBranchNode(
+      selector,
+      atRules,
+      startingStyle,
+      decls,
+      sourceNode,
+      nestedSelector,
+      nestedBlocks
+    )
+  );
+}
+function buildBranchNode(selector, atRules, startingStyle, decls, sourceNode, nestedSelector, nestedBlocks) {
   const rule = applySource(postcss.rule({ selector }), sourceNode);
   let declTarget = rule;
   if (nestedSelector) {
@@ -582,28 +595,29 @@ var rainbowindex = (options = {}) => {
         if (!hasActivation) {
           return;
         }
+        const from = root.source?.input?.file ?? root.source?.input?.id ?? root.source?.input?.from ?? "<rainbowindex>";
         const { compiled, warningSeen } = await compileScannedProject({
           css: rawCSS,
           cwd,
+          cssPath: from,
           surfacePatterns: options.sources,
           onInvalidPattern: (err) => `[RI-1015] ${err}`
         });
         const compilationWarnings = compiled.warnings;
-        const from = root.source?.input?.file ?? root.source?.input?.id ?? root.source?.input?.from ?? "<rainbowindex>";
         stripRIDirectiveNodes(root);
         const slotWarnings = [];
         warnStandaloneSlots(root, slotWarnings);
-        pushWarningsDeduped(compilationWarnings, slotWarnings, warningSeen);
+        pushWarningsDeduped(compilationWarnings, slotWarnings, warningSeen, compiled.suppressed);
         const applyWarnings = [];
-        processApply(root, compiled.theme, applyWarnings);
-        pushWarningsDeduped(compilationWarnings, applyWarnings, warningSeen);
+        processApply(root, compiled.theme, applyWarnings, from);
+        pushWarningsDeduped(compilationWarnings, applyWarnings, warningSeen, compiled.suppressed);
         if (compiled.sections.length > 0) {
           const generatedRoot = postcss2.parse(compiled.sections.join("\n\n"), { from });
           root.prepend(generatedRoot.nodes);
         }
         const cssFnWarnings = [];
         processCSSFunctions(root, compiled.theme, cssFnWarnings);
-        pushWarningsDeduped(compilationWarnings, cssFnWarnings, warningSeen);
+        pushWarningsDeduped(compilationWarnings, cssFnWarnings, warningSeen, compiled.suppressed);
         for (const warning of compilationWarnings) {
           result.warn(warning);
         }

package/dist/chunk-TQJYVQPE.mjs

@@ -0,0 +1,217 @@
+import {
+  createEditorSession
+} from "./chunk-PZDVDEZJ.mjs";
+import {
+  CSS_ENTRY_CANDIDATES,
+  outermostCandidates
+} from "./chunk-WBESS2ZD.mjs";
+import {
+  createNodeImportResolver
+} from "./chunk-W756NVYI.mjs";
+import {
+  isSourceFile
+} from "./chunk-X66Z2YHT.mjs";
+import {
+  extractClassCandidates,
+  hasRIActivation
+} from "./chunk-FJOZJIKB.mjs";
+
+// src/integrations/lint/theme.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { isAbsolute, resolve as resolvePath } from "path";
+function findCSSEntry(cwd) {
+  for (const candidate of CSS_ENTRY_CANDIDATES) {
+    const path = resolvePath(cwd, candidate);
+    if (!existsSync(path)) continue;
+    try {
+      if (hasRIActivation(readFileSync(path, "utf8"))) return path;
+    } catch {
+    }
+  }
+  return null;
+}
+var sessions = /* @__PURE__ */ new Map();
+function mtimeOf(path) {
+  try {
+    return statSync(path).mtimeMs;
+  } catch {
+    return -1;
+  }
+}
+function stampsFor(session, entry) {
+  const stamps = /* @__PURE__ */ new Map([[entry, mtimeOf(entry)]]);
+  for (const file of session.importedFiles) stamps.set(file, mtimeOf(file));
+  return stamps;
+}
+function isStale(cached) {
+  for (const [path, stamp] of cached.stamps) {
+    if (mtimeOf(path) !== stamp) return true;
+  }
+  return false;
+}
+function getSession(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const entry = options.css ? isAbsolute(options.css) ? options.css : resolvePath(cwd, options.css) : findCSSEntry(cwd);
+  if (entry === null) return null;
+  const cached = sessions.get(entry);
+  if (cached && !isStale(cached)) return cached.session;
+  let css;
+  try {
+    css = readFileSync(entry, "utf8");
+  } catch {
+    sessions.delete(entry);
+    return null;
+  }
+  const session = createEditorSession({
+    css,
+    cssPath: entry,
+    resolveImport: createNodeImportResolver({ cwd })
+  });
+  sessions.set(entry, { session, stamps: stampsFor(session, entry) });
+  return session;
+}
+function clearSessionCache() {
+  sessions.clear();
+}
+
+// src/integrations/lint/rules.ts
+function sourceCodeOf(context) {
+  return context.sourceCode ?? context.getSourceCode?.() ?? null;
+}
+function scanPathFor(context) {
+  const filename = context.filename ?? context.getFilename?.() ?? "<input>";
+  return isSourceFile(filename) ? filename : `${filename}.tsx`;
+}
+function optionsOf(context) {
+  const first = context.options?.[0];
+  const options = first && typeof first === "object" ? { ...first } : {};
+  options.cwd ??= context.cwd ?? process.cwd();
+  return options;
+}
+var AUTHORED_ORIGINS = /* @__PURE__ */ new Set(["attribute", "helper", "safelist"]);
+function authoredCandidates(source, path) {
+  return outermostCandidates(extractClassCandidates({ content: source, path })).filter(
+    (candidate) => AUTHORED_ORIGINS.has(candidate.origin)
+  );
+}
+function locOf(sourceCode, candidate) {
+  return {
+    start: sourceCode.getLocFromIndex(candidate.start),
+    end: sourceCode.getLocFromIndex(candidate.end)
+  };
+}
+var THEME_OPTION_SCHEMA = [
+  {
+    type: "object",
+    properties: { css: { type: "string" }, cwd: { type: "string" } },
+    additionalProperties: false
+  }
+];
+var noUnknownClassRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Every class in a class position must compile against the project theme."
+    },
+    hasSuggestions: true,
+    schema: THEME_OPTION_SCHEMA
+  },
+  create(context) {
+    const sourceCode = sourceCodeOf(context);
+    if (sourceCode === null) return {};
+    const session = getSession(optionsOf(context));
+    if (session === null) return {};
+    return {
+      Program(node) {
+        const text = sourceCode.getText();
+        for (const candidate of authoredCandidates(text, scanPathFor(context))) {
+          const result = session.inspector.validate(candidate.value);
+          if (result.ok) continue;
+          const detail = result.reason === "unknown-variant" ? `Unknown variant "${result.offender}"` : result.reason === "invalid-arbitrary" ? `Invalid arbitrary value in "${result.offender}"` : `Unknown utility "${result.offender}"`;
+          const hint = result.suggestion ? ` Did you mean "${result.suggestion}"?` : "";
+          context.report({
+            message: `${detail} \u2014 "${candidate.value}" compiles to nothing.${hint}`,
+            node,
+            loc: locOf(sourceCode, candidate),
+            suggest: suggestionFor(text, candidate, result.offender, result.suggestion)
+          });
+        }
+      }
+    };
+  }
+};
+function suggestionFor(text, candidate, offender, suggestion) {
+  if (suggestion === void 0) return void 0;
+  const slice = text.slice(candidate.start, candidate.end);
+  const at = slice.indexOf(offender);
+  if (at === -1 || slice.indexOf(offender, at + 1) !== -1) return void 0;
+  const range = [candidate.start + at, candidate.start + at + offender.length];
+  return [
+    {
+      desc: `Replace "${offender}" with "${suggestion}"`,
+      fix: (fixer) => fixer.replaceTextRange(range, suggestion)
+    }
+  ];
+}
+function classRuns(text, candidates) {
+  const runs = [];
+  let current = [];
+  let previousEnd = -1;
+  for (const candidate of candidates) {
+    const gap = previousEnd === -1 ? null : text.slice(previousEnd, candidate.start);
+    if (gap !== null && gap.trim() === "") {
+      current.push(candidate);
+    } else {
+      if (current.length > 0) runs.push(current);
+      current = [candidate];
+    }
+    previousEnd = candidate.end;
+  }
+  if (current.length > 0) runs.push(current);
+  return runs;
+}
+var noConflictingClassesRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "One class string must not contain classes that override each other."
+    },
+    schema: THEME_OPTION_SCHEMA
+  },
+  create(context) {
+    const sourceCode = sourceCodeOf(context);
+    if (sourceCode === null) return {};
+    const session = getSession(optionsOf(context));
+    if (session === null) return {};
+    return {
+      Program(node) {
+        const text = sourceCode.getText();
+        for (const run of classRuns(text, authoredCandidates(text, scanPathFor(context)))) {
+          if (run.length < 2) continue;
+          const analysis = session.analyzeMerge(run.map((candidate) => candidate.value));
+          for (const drop of analysis.dropped) {
+            const winners = drop.overriddenBy.map((index) => `"${run[index]?.value ?? "?"}"`).join(", ");
+            context.report({
+              message: `"${drop.className}" is overridden by ${winners} in the same class string, so it has no effect.`,
+              node,
+              loc: locOf(sourceCode, run[drop.index])
+            });
+          }
+        }
+      }
+    };
+  }
+};
+var rules = Object.freeze({
+  "no-unknown-class": noUnknownClassRule,
+  "no-conflicting-classes": noConflictingClassesRule
+});
+
+export {
+  findCSSEntry,
+  getSession,
+  clearSessionCache,
+  noUnknownClassRule,
+  noConflictingClassesRule,
+  rules
+};

package/dist/chunk-W756NVYI.mjs

@@ -0,0 +1,33 @@
+import {
+  MAX_DIRECTIVE_INPUT_SIZE
+} from "./chunk-FJOZJIKB.mjs";
+
+// src/project/resolve-import.ts
+import { readFileSync, statSync } from "fs";
+import { createRequire } from "module";
+import { dirname, resolve as resolvePath } from "path";
+var MAX_IMPORT_FILE_SIZE = MAX_DIRECTIVE_INPUT_SIZE;
+function readIfSmallEnough(path) {
+  const size = statSync(path).size;
+  if (size > MAX_IMPORT_FILE_SIZE) return null;
+  const content = readFileSync(path, "utf8");
+  return { path, content: content.charCodeAt(0) === 65279 ? content.slice(1) : content };
+}
+function createNodeImportResolver(options) {
+  return (specifier, from) => {
+    try {
+      if (specifier.startsWith("./") || specifier.startsWith("../")) {
+        const base = from === void 0 ? options.cwd : dirname(from);
+        return readIfSmallEnough(resolvePath(base, specifier));
+      }
+      const anchor = from ?? resolvePath(options.cwd, "__ri_import_anchor__.js");
+      return readIfSmallEnough(createRequire(anchor).resolve(specifier));
+    } catch {
+      return null;
+    }
+  };
+}
+
+export {
+  createNodeImportResolver
+};