@drskillissue/ganko 0.2.0 → 0.2.5

package/dist/eslint-plugin.js

@@ -14,7 +14,7 @@ import {
   rules3,
   runCrossFileRules,
   runPhases
-} from "./chunk-CAKVXEYV.js";
+} from "./chunk-HIADOXXV.js";
 import "./chunk-EGRHWZRV.js";
 
 // src/eslint-adapter.ts

package/dist/index.cjs

@@ -180,7 +180,8 @@ var ServerSettingsSchema = import_v4.z.object({
   useESLintConfig: import_v4.z.boolean().default(true),
   eslintConfigPath: import_v4.z.string().optional(),
   accessibilityPolicy: AccessibilityPolicySchema.default("wcag-aa"),
-  exclude: import_v4.z.array(import_v4.z.string()).default([])
+  exclude: import_v4.z.array(import_v4.z.string()).default([]),
+  enableTypeScriptDiagnostics: import_v4.z.boolean().default(false)
 });
 var isBun = typeof globalThis.Bun !== "undefined";
 var CHAR_FOLD_BIT = 32;
@@ -3048,6 +3049,7 @@ var GraphCache = class {
     if (this.log.enabled) this.log.debug(
       `setCachedCrossFileResults: ${allDiagnostics.length} diags across ${byFile.size} files solidGen=${this.solidGeneration} cssGen=${this.cssGeneration}`
     );
+    this.crossFileDiagnostics.clear();
     for (const [file, diagnostics] of byFile) {
       this.crossFileDiagnostics.set(file, diagnostics);
     }
@@ -8747,10 +8749,17 @@ function wireJSXHierarchy(graph) {
 }
 function findParentJSXNode(node) {
   let current = node.parent;
+  let crossedFunctionBoundary = false;
   while (current) {
     if (import_typescript29.default.isJsxElement(current) || import_typescript29.default.isJsxFragment(current)) {
       return current;
     }
+    if (import_typescript29.default.isArrowFunction(current) || import_typescript29.default.isFunctionExpression(current)) {
+      crossedFunctionBoundary = true;
+    }
+    if (crossedFunctionBoundary && import_typescript29.default.isJsxAttribute(current)) {
+      return null;
+    }
     current = current.parent;
   }
   return null;
@@ -30904,7 +30913,8 @@ var layoutSignalNames = [
   "inset-block-start",
   "inset-block-end",
   "writing-mode",
-  "direction"
+  "direction",
+  "contain"
 ];
 
 // src/cross-file/layout/offset-baseline.ts
@@ -32537,6 +32547,7 @@ function findNodeModulesPackage(importerFile, packageName) {
 }
 
 // src/cross-file/layout/scope.ts
+var CSS_COLOCATED_EXTENSIONS = [".css"];
 function collectCSSScopeBySolidFile(solids, css, moduleResolver) {
   const resolver = moduleResolver ?? createLayoutModuleResolver(solids, css);
   const cssFilesByNormalizedPath = buildCSSFileIndex(css);
@@ -32547,6 +32558,20 @@ function collectCSSScopeBySolidFile(solids, css, moduleResolver) {
     const solid = solids[i];
     if (!solid) continue;
     const scope = /* @__PURE__ */ new Set();
+    const colocatedCssPath = resolveColocatedCss(solid.file, cssFilesByNormalizedPath);
+    if (colocatedCssPath !== null) {
+      const colocatedScope = getOrCollectTransitiveScope(
+        colocatedCssPath,
+        resolver,
+        cssFilesByNormalizedPath,
+        transitiveScopeByEntryPath
+      );
+      for (let k = 0; k < colocatedScope.length; k++) {
+        const cs = colocatedScope[k];
+        if (!cs) continue;
+        scope.add(cs);
+      }
+    }
     for (let j = 0; j < solid.imports.length; j++) {
       const imp = solid.imports[j];
       if (!imp) continue;
@@ -32589,6 +32614,18 @@ function collectCSSScopeBySolidFile(solids, css, moduleResolver) {
   }
   return out;
 }
+function resolveColocatedCss(solidFilePath, cssFilesByNormalizedPath) {
+  const dotIndex = solidFilePath.lastIndexOf(".");
+  if (dotIndex === -1) return null;
+  const stem = solidFilePath.slice(0, dotIndex);
+  for (let i = 0; i < CSS_COLOCATED_EXTENSIONS.length; i++) {
+    const ext = CSS_COLOCATED_EXTENSIONS[i];
+    if (!ext) continue;
+    const candidate = canonicalPath(stem + ext);
+    if (cssFilesByNormalizedPath.has(candidate)) return candidate;
+  }
+  return null;
+}
 function buildCSSFileIndex(css) {
   const out = /* @__PURE__ */ new Map();
   for (let i = 0; i < css.files.length; i++) {
@@ -33913,73 +33950,108 @@ function compoundGroupNeedsAttributes(groups) {
 }
 function selectorMatchesLayoutElement(matcher, node, perf, fileRootElements = null, logger = noopLogger) {
   const firstCompound = matcher.compoundsRightToLeft[0];
-  if (firstCompound === void 0) return false;
-  if (!matchesCompound(node, firstCompound)) return false;
-  if (matcher.compoundsRightToLeft.length === 1) return true;
-  return matchesChain(matcher, node, 0, perf, fileRootElements, logger);
+  if (firstCompound === void 0) return "no-match";
+  const subjectResult = matchesCompound(node, firstCompound);
+  if (subjectResult === "no-match") return "no-match";
+  if (matcher.compoundsRightToLeft.length === 1) return subjectResult;
+  const chainResult = matchesChain(matcher, node, 0, perf, fileRootElements, logger);
+  if (chainResult === "no-match") return "no-match";
+  if (subjectResult === "conditional" || chainResult === "conditional") return "conditional";
+  return "match";
 }
 function matchesChain(matcher, node, index, perf, fileRootElements, logger) {
   const combinator = matcher.combinatorsRightToLeft[index];
-  if (combinator === void 0) return false;
+  if (combinator === void 0) return "no-match";
   const nextIndex = index + 1;
   const targetCompound = matcher.compoundsRightToLeft[nextIndex];
-  if (targetCompound === void 0) return false;
+  if (targetCompound === void 0) return "no-match";
   const isFinal = nextIndex === matcher.compoundsRightToLeft.length - 1;
   if (combinator === "child") {
     const parent = node.parentElementNode;
-    if (parent === null) return false;
+    if (parent === null) return "no-match";
     perf.ancestryChecks++;
-    if (!matchesCompound(parent, targetCompound)) return false;
-    if (isFinal) return true;
-    return matchesChain(matcher, parent, nextIndex, perf, fileRootElements, logger);
+    const compoundResult = matchesCompound(parent, targetCompound);
+    if (compoundResult === "no-match") return "no-match";
+    if (isFinal) return compoundResult;
+    const chainResult = matchesChain(matcher, parent, nextIndex, perf, fileRootElements, logger);
+    return mergeMatchResults(compoundResult, chainResult);
   }
   if (combinator === "adjacent") {
     const sibling = node.previousSiblingNode;
-    if (sibling === null) return false;
+    if (sibling === null) return "no-match";
     perf.ancestryChecks++;
-    if (!matchesCompound(sibling, targetCompound)) return false;
-    if (isFinal) return true;
-    return matchesChain(matcher, sibling, nextIndex, perf, fileRootElements, logger);
+    const compoundResult = matchesCompound(sibling, targetCompound);
+    if (compoundResult === "no-match") return "no-match";
+    if (isFinal) return compoundResult;
+    const chainResult = matchesChain(matcher, sibling, nextIndex, perf, fileRootElements, logger);
+    return mergeMatchResults(compoundResult, chainResult);
   }
   if (combinator === "sibling") {
     let sibling = node.previousSiblingNode;
     while (sibling !== null) {
       perf.ancestryChecks++;
-      if (matchesCompound(sibling, targetCompound)) {
-        if (isFinal) return true;
-        if (matchesChain(matcher, sibling, nextIndex, perf, fileRootElements, logger)) return true;
+      const compoundResult = matchesCompound(sibling, targetCompound);
+      if (compoundResult !== "no-match") {
+        if (isFinal) return compoundResult;
+        const chainResult = matchesChain(matcher, sibling, nextIndex, perf, fileRootElements, logger);
+        if (chainResult !== "no-match") return mergeMatchResults(compoundResult, chainResult);
       }
       sibling = sibling.previousSiblingNode;
     }
-    return false;
+    return "no-match";
   }
+  let bestResult = "no-match";
   let ancestor = node.parentElementNode;
   while (ancestor !== null) {
     perf.ancestryChecks++;
-    if (matchesCompound(ancestor, targetCompound)) {
-      if (isFinal) return true;
-      if (matchesChain(matcher, ancestor, nextIndex, perf, fileRootElements, logger)) return true;
+    const compoundResult = matchesCompound(ancestor, targetCompound);
+    if (compoundResult !== "no-match") {
+      if (isFinal) return compoundResult;
+      const chainResult = matchesChain(matcher, ancestor, nextIndex, perf, fileRootElements, logger);
+      if (chainResult !== "no-match") {
+        const merged = mergeMatchResults(compoundResult, chainResult);
+        if (merged === "match") return "match";
+        bestResult = merged;
+      }
     }
     ancestor = ancestor.parentElementNode;
   }
   if (fileRootElements !== null) {
+    if (logger.enabled) {
+      const compoundDesc = describeCompound(targetCompound);
+      logger.trace(`[selector-match] fallback: node=${node.key} tag=${node.tagName} checking ${fileRootElements.length} roots for compound=${compoundDesc}`);
+    }
     for (let r = 0; r < fileRootElements.length; r++) {
       const root = fileRootElements[r];
       if (root === void 0) continue;
       if (root === node) continue;
       if (root.solidFile !== node.solidFile) continue;
       perf.ancestryChecks++;
-      if (matchesCompound(root, targetCompound)) {
+      const compoundResult = matchesCompound(root, targetCompound);
+      if (logger.enabled && compoundResult === "no-match") {
+        logger.trace(`[selector-match] fallback MISS: root=${root.key} tag=${root.tagName} attrs=[${[...root.attributes.entries()].map(([k, v]) => `${k}=${v}`).join(",")}]`);
+      }
+      if (compoundResult !== "no-match") {
         if (logger.enabled) {
           const compoundDesc = describeCompound(targetCompound);
           logger.debug(`[selector-match] fallback HIT: node=${node.key} tag=${node.tagName} matched root=${root.key} tag=${root.tagName} compound=${compoundDesc} isFinal=${isFinal}`);
         }
-        if (isFinal) return true;
-        if (matchesChain(matcher, root, nextIndex, perf, fileRootElements, logger)) return true;
+        if (isFinal) return compoundResult;
+        const chainResult = matchesChain(matcher, root, nextIndex, perf, fileRootElements, logger);
+        if (chainResult !== "no-match") {
+          const merged = mergeMatchResults(compoundResult, chainResult);
+          if (merged === "match") return "match";
+          bestResult = merged;
+        }
       }
     }
   }
-  return false;
+  return bestResult;
+}
+function mergeMatchResults(a, b) {
+  if (a === "no-match" || b === "no-match") return "no-match";
+  if (a === "conditional" || b === "conditional") return "conditional";
+  return "match";
 }
 function describeCompound(compound) {
   const parts = [];
@@ -33999,15 +34071,16 @@ function describeCompound(compound) {
   return parts.join("") || "*";
 }
 function matchesCompound(node, compound) {
-  if (compound.tagName !== null && node.tagName !== compound.tagName) return false;
+  if (compound.tagName !== null && node.tagName !== compound.tagName) return "no-match";
   if (compound.idValue !== null) {
     const id = node.attributes.get("id");
-    if (id !== compound.idValue) return false;
+    if (id !== compound.idValue) return "no-match";
   }
-  if (!matchesRequiredClasses(compound.classes, node.classTokenSet)) return false;
-  if (!matchesRequiredAttributes(compound.attributes, node.attributes)) return false;
-  if (!matchesPseudoConstraints(node, compound.pseudo)) return false;
-  return true;
+  if (!matchesRequiredClasses(compound.classes, node.classTokenSet)) return "no-match";
+  const attrResult = matchesRequiredAttributes(compound.attributes, node.attributes);
+  if (attrResult === "no-match") return "no-match";
+  if (!matchesPseudoConstraints(node, compound.pseudo)) return "no-match";
+  return attrResult;
 }
 function matchesPseudoConstraints(node, pseudo) {
   if (pseudo.firstChild && node.siblingIndex !== 1) return false;
@@ -34032,7 +34105,7 @@ function matchesPseudoConstraints(node, pseudo) {
     for (let j = 0; j < group.length; j++) {
       const compound = group[j];
       if (compound === void 0) continue;
-      if (!matchesCompound(node, compound)) continue;
+      if (matchesCompound(node, compound) === "no-match") continue;
       matched = true;
       break;
     }
@@ -34044,7 +34117,7 @@ function matchesPseudoConstraints(node, pseudo) {
     for (let j = 0; j < group.length; j++) {
       const compound = group[j];
       if (compound === void 0) continue;
-      if (!matchesCompound(node, compound)) continue;
+      if (matchesCompound(node, compound) === "no-match") continue;
       return false;
     }
   }
@@ -34689,19 +34762,24 @@ function matchesRequiredClasses(required, actual) {
   return true;
 }
 function matchesRequiredAttributes(required, actual) {
-  if (required.length === 0) return true;
+  if (required.length === 0) return "match";
+  let hasConditional = false;
   for (let i = 0; i < required.length; i++) {
     const constraint = required[i];
     if (constraint === void 0) continue;
-    if (!actual.has(constraint.name)) return false;
+    if (!actual.has(constraint.name)) return "no-match";
     if (constraint.operator === "exists") continue;
     const actualValue = actual.get(constraint.name);
-    if (actualValue === null || actualValue === void 0) return false;
-    if (constraint.value === null) return false;
+    if (actualValue === void 0) return "no-match";
+    if (actualValue === null) {
+      hasConditional = true;
+      continue;
+    }
+    if (constraint.value === null) return "no-match";
     if (matchesAttributeValue(actualValue, constraint)) continue;
-    return false;
+    return "no-match";
   }
-  return true;
+  return hasConditional ? "conditional" : "match";
 }
 function matchesAttributeValue(actualValue, constraint) {
   const expectedValue = constraint.value;
@@ -37067,6 +37145,11 @@ function compareCascadePositions(posA, posB) {
 }
 
 // src/cross-file/layout/cascade-builder.ts
+var DYNAMIC_ATTRIBUTE_GUARD = {
+  kind: 1 /* Conditional */,
+  conditions: [{ kind: "dynamic-attribute", query: null, key: "dynamic-attribute:*" }],
+  key: "dynamic-attribute:*"
+};
 var SCROLLABLE_VALUES = /* @__PURE__ */ new Set(["auto", "scroll"]);
 var EMPTY_EXPANSION_RESULT = [];
 function collectMonitoredDeclarations(selector, layerOrder, guard) {
@@ -37141,14 +37224,21 @@ function appendMatchingEdgesFromSelectorIds(ctx, selectorIds, node, applies, app
     if (!selector) {
       throw new Error(`missing selector ${selectorId}`);
     }
-    if (!selectorMatchesLayoutElement(metadata.matcher, node, ctx.perf, fileRoots, ctx.logger)) continue;
+    const matchResult = selectorMatchesLayoutElement(metadata.matcher, node, ctx.perf, fileRoots, ctx.logger);
+    if (matchResult === "no-match") continue;
     const edge = {
       selectorId: selector.id,
       specificityScore: selector.specificityScore,
-      sourceOrder: selector.rule.sourceOrder
+      sourceOrder: selector.rule.sourceOrder,
+      conditionalMatch: matchResult === "conditional"
     };
     applies.push(edge);
     ctx.perf.matchEdgesCreated++;
+    if (ctx.logger.enabled) {
+      ctx.logger.trace(
+        `[cascade] edge node=${node.key} selector=${selector.id} match=${matchResult} conditional=${edge.conditionalMatch} selector-raw=${selector.raw.slice(0, 80)}`
+      );
+    }
     const existing = appliesByElementNodeMutable.get(node);
     if (existing) {
       existing.push(edge);
@@ -37209,10 +37299,11 @@ function buildCascadeMapForElement(node, edges, monitoredDeclarationsBySelectorI
       const declaration = declarations[j];
       if (!declaration) continue;
       const property = declaration.property;
+      const guardProvenance = edge.conditionalMatch && declaration.guardProvenance.kind === 0 /* Unconditional */ ? DYNAMIC_ATTRIBUTE_GUARD : declaration.guardProvenance;
       const newDeclaration = {
         value: declaration.value,
         source: 0 /* Selector */,
-        guardProvenance: declaration.guardProvenance
+        guardProvenance
       };
       const existingPosition = positions.get(property);
       if (existingPosition === void 0) {
@@ -37326,7 +37417,7 @@ function buildConditionalDeltaIndex(elements, appliesByNode, monitoredDeclaratio
               };
               byProperty.set(property, bucket);
             }
-            if (declaration.guardProvenance.kind === 1 /* Conditional */) {
+            if (declaration.guardProvenance.kind === 1 /* Conditional */ || currentEdge.conditionalMatch) {
               bucket.conditional.add(expandedEntry.value);
               continue;
             }
@@ -37818,6 +37909,23 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
   const moduleResolver = createLayoutModuleResolver(solids, css);
   const componentHostResolver = createLayoutComponentHostResolver(solids, moduleResolver, logger);
   const cssScopeBySolidFile = collectCSSScopeBySolidFile(solids, css, moduleResolver);
+  if (logger.enabled) {
+    for (const [solidFile, scopePaths] of cssScopeBySolidFile) {
+      if (scopePaths.length > 0) {
+        let names = "";
+        for (let k = 0; k < scopePaths.length; k++) {
+          const p = scopePaths[k];
+          if (!p) continue;
+          if (names.length > 0) names += ", ";
+          const slash = p.lastIndexOf("/");
+          names += slash === -1 ? p : p.slice(slash + 1);
+        }
+        logger.trace(`[scope] ${solidFile} \u2192 ${scopePaths.length} CSS files: ${names}`);
+      } else {
+        logger.trace(`[scope] ${solidFile} \u2192 EMPTY (no CSS in scope)`);
+      }
+    }
+  }
   const selectorIndexStartedAt = performance.now();
   const scopedSelectorsBySolidFile = buildScopedSelectorIndexBySolidFile(
     cssScopeBySolidFile,
@@ -37960,6 +38068,22 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
     appliesByNode.set(node, edges);
   }
   perf.cascadeBuildMs = performance.now() - cascadeStartedAt;
+  if (logger.enabled) {
+    for (let i = 0; i < elements.length; i++) {
+      const node = elements[i];
+      if (!node) continue;
+      const cascade = cascadeByElementNode.get(node);
+      if (!cascade || cascade.size === 0) continue;
+      const displayDecl = cascade.get("display");
+      const flexDirDecl = cascade.get("flex-direction");
+      if (!displayDecl && !flexDirDecl) continue;
+      const displayGuard = displayDecl?.guardProvenance.kind === 1 /* Conditional */ ? "conditional" : "unconditional";
+      const flexDirGuard = flexDirDecl?.guardProvenance.kind === 1 /* Conditional */ ? "conditional" : "unconditional";
+      logger.trace(
+        `[cascade] node=${node.key} tag=${node.tagName ?? "null"} display=${displayDecl ? `${displayDecl.value}(${displayGuard})` : "absent"} flex-direction=${flexDirDecl ? `${flexDirDecl.value}(${flexDirGuard})` : "absent"} edges=${(appliesByNode.get(node) ?? []).length} attrs=[${[...node.attributes.keys()].join(",")}]`
+      );
+    }
+  }
   const snapshotByElementNode = buildSignalSnapshotIndex(elements, cascadeByElementNode, perf);
   const measurementNodeByRootKey = buildMeasurementNodeIndex(elements, childrenByParentNodeMutable, snapshotByElementNode);
   const factIndex = buildElementFactIndex(elements, snapshotByElementNode);
@@ -37977,7 +38101,7 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
     layoutOffsetSignals
   );
   const statefulRuleIndexes = buildStatefulRuleIndexes(css.rules);
-  const contextByParentNode = buildContextIndex(childrenByParentNodeMutable, snapshotByElementNode, perf);
+  const contextByParentNode = buildContextIndex(childrenByParentNodeMutable, snapshotByElementNode, perf, logger);
   const cohortIndex = buildCohortIndex({
     childrenByParentNode: childrenByParentNodeMutable,
     contextByParentNode,
@@ -38397,16 +38521,27 @@ function computeFlowParticipationFact(snapshot) {
     hasUnconditionalOutOfFlow: signal.guard.kind === 0 /* Unconditional */ && outOfFlow
   };
 }
-function buildContextIndex(childrenByParentNode, snapshotByElementNode, perf) {
+function buildContextIndex(childrenByParentNode, snapshotByElementNode, perf, logger) {
   const out = /* @__PURE__ */ new Map();
+  const trace = logger.enabled;
   for (const [parent, children] of childrenByParentNode) {
     if (children.length < 2) continue;
     const snapshot = snapshotByElementNode.get(parent);
     if (!snapshot) {
       throw new Error(`missing parent snapshot for context classification ${parent.key}`);
     }
-    out.set(parent, createAlignmentContextForParent(parent, snapshot));
+    const ctx = createAlignmentContextForParent(parent, snapshot);
+    out.set(parent, ctx);
     perf.contextsClassified++;
+    if (trace) {
+      const displaySignal = snapshot.signals.get("display");
+      const flexDirSignal = snapshot.signals.get("flex-direction");
+      const displayDesc = displaySignal ? `${displaySignal.kind}:${displaySignal.kind === "known" ? displaySignal.normalized : "?"}(guard=${displaySignal.guard.kind === 1 /* Conditional */ ? "conditional" : "unconditional"})` : "absent";
+      const flexDirDesc = flexDirSignal ? `${flexDirSignal.kind}:${flexDirSignal.kind === "known" ? flexDirSignal.normalized : "?"}(guard=${flexDirSignal.guard.kind === 1 /* Conditional */ ? "conditional" : "unconditional"})` : "absent";
+      logger.trace(
+        `[context] parent=${parent.key} tag=${parent.tagName ?? "null"} children=${children.length} display=${displayDesc} flex-direction=${flexDirDesc} \u2192 kind=${ctx.kind} certainty=${ctx.certainty} crossAxisIsBlockAxis=${ctx.crossAxisIsBlockAxis} baseline=${ctx.baselineRelevance}`
+      );
+    }
   }
   return out;
 }
@@ -39894,7 +40029,13 @@ var MIN_OFFSET_PX_THRESHOLD = 2;
 var siblingAlignmentDetector = {
   id: "sibling-alignment-outlier",
   collect: collectAlignmentCases,
-  evaluate(input) {
+  evaluate(input, context) {
+    if (context.logger.enabled) {
+      const ctx = input.context;
+      context.logger.trace(
+        `[sibling-alignment] evaluate subject=${input.subject.elementKey} tag=${input.subject.tag} parent=${ctx.parentElementKey} parentTag=${ctx.parentTag} context.kind=${ctx.kind} certainty=${ctx.certainty} display=${ctx.parentDisplay} alignItems=${ctx.parentAlignItems} crossAxisIsBlockAxis=${ctx.crossAxisIsBlockAxis} crossAxisCertainty=${ctx.crossAxisIsBlockAxisCertainty} baseline=${ctx.baselineRelevance}`
+      );
+    }
     const decision = evaluateAlignmentCase(input);
     if (decision.kind === "reject") {
       return {
@@ -41012,8 +41153,16 @@ function isExemptFromCLS(layout, solidFile, element, property) {
   if (POSITIONED_OFFSET_PROPERTIES.has(property) && flowFact.position !== null && flowFact.position !== "static") {
     return true;
   }
+  if (hasLayoutContainment(node) || node.parentElementNode !== null && hasLayoutContainment(node.parentElementNode)) {
+    return true;
+  }
   return false;
 }
+function hasLayoutContainment(node) {
+  const contain = node.inlineStyleValues.get("contain");
+  if (contain === void 0) return false;
+  return contain === "layout" || contain === "strict" || contain === "content" || contain.includes("layout");
+}
 function hasUnstableLayoutDelta(property, node) {
   const unwrapped = unwrapTypeWrapper(node);
   if (isStaticComparable(property, unwrapped)) return false;