@pandacss/eslint-plugin 0.3.2 → 2.0.0-beta.11

package/dist/chunk-QIP545JU.js

@@ -0,0 +1,1261 @@
+// src/rules/shared.ts
+function getSourceText(context) {
+  return context.sourceCode?.text ?? context.sourceCode?.getText?.() ?? "";
+}
+function byteToIndex(text, byteOffset) {
+  let bytes = 0;
+  for (let i = 0; i < text.length; ) {
+    if (bytes >= byteOffset) return i;
+    const cp = text.codePointAt(i);
+    bytes += cp <= 127 ? 1 : cp <= 2047 ? 2 : cp <= 65535 ? 3 : 4;
+    i += cp > 65535 ? 2 : 1;
+  }
+  return text.length;
+}
+function toEslintLoc(range) {
+  return {
+    start: {
+      line: range.start.line,
+      column: Math.max(0, range.start.column - 1)
+    },
+    end: {
+      line: range.end.line,
+      column: Math.max(0, range.end.column - 1)
+    }
+  };
+}
+
+// src/rules/consistent-property-style.ts
+var consistentPropertyStyleRuleName = "consistent-property-style";
+function createConsistentPropertyStyleRule(options) {
+  const aliasOf = {};
+  for (const [alias, canonical] of Object.entries(options.shorthands)) {
+    const current = aliasOf[canonical];
+    if (current === void 0 || alias.length < current.length || alias.length === current.length && alias < current) {
+      aliasOf[canonical] = alias;
+    }
+  }
+  return {
+    meta: {
+      type: "suggestion",
+      docs: {
+        description: "Enforce a consistent property style: Panda shorthand aliases or longhand canonical names."
+      },
+      fixable: "code",
+      schema: [
+        {
+          type: "object",
+          properties: {
+            style: { enum: ["shorthand", "longhand"] },
+            ignore: { type: "array", items: { type: "string" }, uniqueItems: true }
+          },
+          additionalProperties: false
+        }
+      ],
+      messages: {
+        useShorthand: 'Use the shorthand "{{target}}" instead of "{{current}}".',
+        useLonghand: 'Use the longhand "{{target}}" instead of "{{current}}".'
+      }
+    },
+    create(context) {
+      const configured = context.options?.[0];
+      const style = configured?.style ?? "longhand";
+      const ignore = new Set(configured?.ignore ?? []);
+      const source = getSourceText(context);
+      return {
+        Program() {
+          const inspection = options.inspect(context);
+          if (!inspection) return;
+          for (const entry of inspection.styleEntries) {
+            if (entry.kind !== "utility") continue;
+            const name = entry.name;
+            if (ignore.has(name)) continue;
+            const target = style === "longhand" ? options.shorthands[name] : options.shorthands[name] === void 0 ? aliasOf[name] : void 0;
+            if (target === void 0 || target === name) continue;
+            const descriptor = {
+              messageId: style === "shorthand" ? "useShorthand" : "useLonghand",
+              data: { target, current: name },
+              loc: toEslintLoc(entry.range)
+            };
+            if (entry.fixable === "safe" && entry.keySpan && source) {
+              const range = [
+                byteToIndex(source, entry.keySpan.start),
+                byteToIndex(source, entry.keySpan.end)
+              ];
+              descriptor.fix = (fixer) => fixer.replaceTextRange(range, target);
+            }
+            context.report(descriptor);
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/rules/extraction-diagnostics.ts
+var extractionDiagnosticsRuleName = "extraction-diagnostics";
+function createExtractionDiagnosticsRule(options) {
+  return {
+    meta: {
+      type: "problem",
+      docs: {
+        description: "Report Panda extraction diagnostics for the current file."
+      },
+      schema: [],
+      messages: {
+        diagnostic: "{{message}}"
+      }
+    },
+    create(context) {
+      return {
+        Program() {
+          const inspection = options.inspect(context);
+          if (!inspection) return;
+          reportDiagnostics(context, inspection.diagnostics);
+        }
+      };
+    }
+  };
+}
+function reportDiagnostics(context, diagnostics) {
+  for (const diagnostic of diagnostics) {
+    context.report({
+      messageId: "diagnostic",
+      data: { message: diagnostic.message },
+      ...diagnostic.location ? { loc: toEslintLoc(diagnostic.location) } : {}
+    });
+  }
+}
+
+// src/rules/tokens.ts
+var noInvalidTokenPathsRuleName = "no-invalid-token-paths";
+function createNoInvalidTokenPathsRule(options) {
+  return createTokenRule({
+    description: "Report unresolved Panda token references for the current file.",
+    message: 'Panda token "{{token}}" was not found.',
+    inspect: options.inspect,
+    report(inspection, context) {
+      for (const tokenRef of inspection.tokenRefs) {
+        if (tokenRef.resolved) continue;
+        reportToken(context, tokenRef.path, tokenRef.range);
+      }
+    }
+  });
+}
+function createTokenRule(config) {
+  return {
+    meta: {
+      type: "problem",
+      docs: {
+        description: config.description
+      },
+      schema: [],
+      messages: {
+        token: config.message
+      }
+    },
+    create(context) {
+      return {
+        Program() {
+          const inspection = config.inspect(context);
+          if (!inspection) return;
+          config.report(inspection, context);
+        }
+      };
+    }
+  };
+}
+function reportToken(context, token, range) {
+  context.report({
+    messageId: "token",
+    data: { token },
+    loc: toEslintLoc(range)
+  });
+}
+
+// src/core/inspector.ts
+import { FileInspector, sourceCacheKey } from "@pandacss/compiler/tooling";
+
+// src/core/project-cache.ts
+import { createProjectFromConfig } from "@pandacss/compiler/tooling";
+var ProjectCache = class {
+  #projects = /* @__PURE__ */ new Map();
+  #createProject;
+  constructor(options = {}) {
+    this.#createProject = options.createProject ?? ((settings) => createProjectFromConfig({ cwd: settings.cwd, configPath: settings.configPath }));
+  }
+  get(settings) {
+    const key = projectCacheKey(settings);
+    const cached = this.#projects.get(key);
+    if (cached) return cached;
+    const project = this.#createProject(settings);
+    this.#projects.set(key, project);
+    return project;
+  }
+  clear() {
+    this.#projects.clear();
+  }
+};
+function projectCacheKey(settings) {
+  return `${settings.cwd}\0${settings.configPath ?? ""}`;
+}
+
+// src/core/settings.ts
+function resolvePandaSettings(context) {
+  const settings = context.settings ?? {};
+  const panda = isObject(settings.panda) ? settings.panda : {};
+  const migrationConfigPath = settings["@pandacss/configPath"];
+  return {
+    configPath: stringSetting(panda.configPath) ?? stringSetting(migrationConfigPath),
+    cwd: stringSetting(panda.cwd) ?? context.cwd ?? process.cwd(),
+    strictDiagnostics: panda.strictDiagnostics === true
+  };
+}
+function stringSetting(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/core/linter.ts
+var Linter = class {
+  #projectCache;
+  #inspector;
+  constructor(options = {}) {
+    this.#projectCache = options.projectCache ?? new ProjectCache();
+    this.#inspector = options.inspector ?? new FileInspector();
+  }
+  getProject(context) {
+    return this.#projectCache.get(resolvePandaSettings(context));
+  }
+  async inspect(context) {
+    const settings = resolvePandaSettings(context);
+    const project = await this.#projectCache.get(settings);
+    const path = getContextFilename(context);
+    const source = getContextSource(context);
+    const result = this.inspectProject(project, path, source);
+    return { project, settings, path, source, result };
+  }
+  inspectProject(project, path, source) {
+    return this.#inspector.inspect(project.compiler, path, source);
+  }
+  clear() {
+    this.#projectCache.clear();
+    this.#inspector.clear();
+  }
+};
+function getContextFilename(context) {
+  return cleanFilename(context.physicalFilename) ?? cleanFilename(context.filename) ?? cleanFilename(context.getPhysicalFilename?.()) ?? cleanFilename(context.getFilename?.()) ?? "<unknown>";
+}
+function getContextSource(context) {
+  const sourceCode = context.sourceCode ?? context.getSourceCode?.();
+  return sourceCode?.text ?? sourceCode?.getText?.() ?? "";
+}
+function cleanFilename(value) {
+  if (!value || value === "<text>" || value === "<input>") return void 0;
+  return value;
+}
+
+// src/rules/file-not-included.ts
+var fileNotIncludedRuleName = "file-not-included";
+var MESSAGE = "This file uses Panda but is not part of the Panda config `include` globs, so its styles will not be generated.";
+function createFileNotIncludedRule(options) {
+  return {
+    meta: {
+      type: "problem",
+      docs: {
+        description: "Report files that use Panda but are excluded from the config `include` globs."
+      },
+      schema: [],
+      messages: {
+        notIncluded: MESSAGE
+      }
+    },
+    create(context) {
+      return {
+        Program() {
+          const path = getContextFilename(context);
+          if (options.isSourceFile(path)) return;
+          const inspection = options.inspect(context);
+          if (!inspection) return;
+          const usesPanda = inspection.calls.length > 0 || inspection.jsx.length > 0 || inspection.styleEntries.length > 0 || inspection.tokenRefs.length > 0;
+          if (!usesPanda) return;
+          context.report({
+            messageId: "notIncluded",
+            loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } }
+          });
+        }
+      };
+    }
+  };
+}
+
+// src/rules/no-debug.ts
+var noDebugRuleName = "no-debug";
+var MESSAGE2 = "Remove the `debug` property; it logs generated styles and should not ship.";
+function createNoDebugRule(options) {
+  return {
+    meta: {
+      type: "problem",
+      docs: {
+        description: "Report the Panda `debug` property left in source."
+      },
+      schema: [],
+      messages: {
+        debug: MESSAGE2
+      }
+    },
+    create(context) {
+      return {
+        Program() {
+          const inspection = options.inspect(context);
+          if (!inspection) return;
+          for (const entry of inspection.styleEntries) {
+            if (entry.name !== "debug") continue;
+            context.report({ messageId: "debug", loc: toEslintLoc(entry.range) });
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/rules/no-deprecated.ts
+var noDeprecatedRuleName = "no-deprecated";
+var ALL_KINDS = ["tokens", "utilities", "recipes", "patterns"];
+function stripModifier(path) {
+  const slash = path.indexOf("/");
+  return slash === -1 ? path : path.slice(0, slash);
+}
+function createNoDeprecatedRule(options) {
+  return {
+    meta: {
+      type: "problem",
+      docs: {
+        description: "Report usage of deprecated Panda tokens, utilities, and recipes."
+      },
+      schema: [
+        {
+          type: "object",
+          properties: {
+            kinds: { type: "array", items: { enum: [...ALL_KINDS] }, uniqueItems: true }
+          },
+          additionalProperties: false
+        }
+      ],
+      messages: {
+        deprecated: 'Panda {{kind}} "{{name}}" is deprecated.{{note}}'
+      }
+    },
+    create(context) {
+      const configured = context.options?.[0]?.kinds;
+      const kinds = new Set(configured ?? ALL_KINDS);
+      return {
+        Program() {
+          const inspection = options.inspect(context);
+          if (!inspection) return;
+          if (kinds.has("tokens")) {
+            for (const usage of inspection.usages) {
+              if (usage.kind !== "token") continue;
+              const path = stripModifier(usage.name);
+              const deprecation = options.tokens[path];
+              if (deprecation === void 0) continue;
+              report(context, "token", path, deprecation, usage.range);
+            }
+          }
+          if (kinds.has("utilities")) {
+            for (const entry of inspection.styleEntries) {
+              if (entry.kind !== "utility") continue;
+              const prop = entry.canonicalName ?? entry.name;
+              const deprecation = options.utilities[prop];
+              if (deprecation === void 0) continue;
+              report(context, "property", prop, deprecation, entry.range);
+            }
+          }
+          if (kinds.has("recipes")) {
+            reportRecipes(context, inspection, options.recipes);
+          }
+          if (kinds.has("patterns")) {
+            reportPatterns(context, inspection, options.patterns);
+          }
+        }
+      };
+    }
+  };
+}
+function reportRecipes(context, inspection, recipes) {
+  reportComponents(
+    context,
+    "recipe",
+    recipes,
+    inspection.componentEntries.map((entry) => ({ name: entry.recipe, range: entry.range })),
+    inspection.usages.filter((usage) => usage.kind === "recipe")
+  );
+}
+function reportPatterns(context, inspection, patterns) {
+  reportComponents(
+    context,
+    "pattern",
+    patterns,
+    inspection.componentEntries.map((entry) => ({ name: entry.pattern, range: entry.range })),
+    inspection.usages.filter((usage) => usage.kind === "pattern")
+  );
+}
+function reportComponents(context, kind, deprecations, fromComponents, fromUsages) {
+  const seen = /* @__PURE__ */ new Set();
+  const emit = (name, range) => {
+    if (!name) return;
+    const deprecation = deprecations[name];
+    if (deprecation === void 0) return;
+    const key = `${range.start.line}:${range.start.column}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    report(context, kind, name, deprecation, range);
+  };
+  for (const entry of fromComponents) emit(entry.name, entry.range);
+  for (const usage of fromUsages) emit(usage.name, usage.range);
+}
+function report(context, kind, name, deprecation, range) {
+  const note = typeof deprecation === "string" ? ` ${deprecation}` : "";
+  context.report({
+    messageId: "deprecated",
+    data: { kind, name, note },
+    loc: toEslintLoc(range)
+  });
+}
+
+// src/rules/no-important.ts
+var noImportantRuleName = "no-important";
+var MESSAGE3 = "Avoid `!important`; it escalates specificity and is hard to override.";
+function hasImportant(value) {
+  if (typeof value === "string") {
+    const v = value.trim().toLowerCase();
+    return v.endsWith("!") || v.endsWith("!important");
+  }
+  if (Array.isArray(value)) return value.some(hasImportant);
+  if (value && typeof value === "object") return Object.values(value).some(hasImportant);
+  return false;
+}
+function createNoImportantRule(options) {
+  return {
+    meta: {
+      type: "problem",
+      docs: { description: "Disallow `!important` in Panda styles." },
+      schema: [],
+      messages: { important: MESSAGE3 }
+    },
+    create(context) {
+      return {
+        Program() {
+          const inspection = options.inspect(context);
+          if (!inspection) return;
+          for (const entry of inspection.styleEntries) {
+            if (entry.kind === "condition" || entry.kind === "selector") continue;
+            if (hasImportant(entry.resolvedValue)) {
+              context.report({ messageId: "important", loc: toEslintLoc(entry.range) });
+            }
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/rules/no-invalid-nesting.ts
+var noInvalidNestingRuleName = "no-invalid-nesting";
+function isSelectorKey(name) {
+  const trimmed = name.trim();
+  return /^[:.#[*>+~]/.test(trimmed) || trimmed.includes(":");
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createNoInvalidNestingRule(options) {
+  return {
+    meta: {
+      type: "problem",
+      docs: { description: 'Disallow nested selectors that omit "&", which Panda silently ignores.' },
+      schema: [],
+      messages: {
+        nesting: 'Nested selector "{{selector}}" has no "&", so Panda ignores it. Use "{{fixed}}" or a condition like "_hover".'
+      },
+      hasSuggestions: true
+    },
+    create(context) {
+      const source = getSourceText(context);
+      return {
+        Program() {
+          const inspection = options.inspect(context);
+          if (!inspection) return;
+          for (const entry of inspection.styleEntries) {
+            const nestable = entry.kind === "unknown" || entry.kind === "recipe-variant";
+            if (!nestable || !isSelectorKey(entry.name) || !isObject2(entry.resolvedValue)) continue;
+            const fixed = `&${entry.name}`;
+            const descriptor = {
+              messageId: "nesting",
+              data: { selector: entry.name, fixed },
+              loc: toEslintLoc(entry.range)
+            };
+            if (entry.fixable === "safe" && entry.keySpan && source) {
+              const range = [
+                byteToIndex(source, entry.keySpan.start),
+                byteToIndex(source, entry.keySpan.end)
+              ];
+              descriptor.suggest = [
+                { desc: `Prefix with "&" \u2192 "${fixed}"`, fix: (fixer) => fixer.replaceTextRange(range, `'${fixed}'`) }
+              ];
+            }
+            context.report(descriptor);
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/rules/no-primitive-token.ts
+var noPrimitiveTokenRuleName = "no-primitive-token";
+var MAX_SUGGESTIONS = 3;
+function isAllowed(token, allow) {
+  if (allow.size === 0) return false;
+  return allow.has(token.path) || allow.has(token.categoryPath);
+}
+function modifierSuffix(token, sourcePath) {
+  if (sourcePath?.startsWith(`${token.path}/`)) return sourcePath.slice(token.path.length);
+  return token.modifier ? `/${token.modifier}` : "";
+}
+function shouldReport(token, config) {
+  if (token.semantic || !token.semanticCategory) return false;
+  if (config.categories && !config.categories.has(token.category)) return false;
+  return !isAllowed(token, config.allow);
+}
+function replacementForRange(source, range, value) {
+  const current = source.slice(range[0], range[1]);
+  const quote = current[0];
+  return quote === '"' || quote === "'" || quote === "`" ? `${quote}${value}${quote}` : value;
+}
+function tokenRefFixRange(source, span, token) {
+  const outerStart = byteToIndex(source, span.start);
+  const outerEnd = byteToIndex(source, span.end);
+  const text = source.slice(outerStart, outerEnd);
+  for (const quote of ["'", '"', "`"]) {
+    const needle = `${quote}${token}${quote}`;
+    const index2 = text.indexOf(needle);
+    if (index2 >= 0) return [outerStart + index2, outerStart + index2 + needle.length];
+  }
+  const index = text.indexOf(token);
+  return index >= 0 ? [outerStart + index, outerStart + index + token.length] : void 0;
+}
+function tokenRefSourcePath(source, span, path) {
+  const outerStart = byteToIndex(source, span.start);
+  const outerEnd = byteToIndex(source, span.end);
+  const text = source.slice(outerStart, outerEnd);
+  const index = text.indexOf(path);
+  if (index < 0) return path;
+  let end = index + path.length;
+  if (text[end] === "/") {
+    end += 1;
+    while (end < text.length && !["'", '"', "`", ",", ")", " ", "\n", "\r", "	"].includes(text[end])) end += 1;
+  }
+  return text.slice(index, end);
+}
+function reportPrimitiveToken(context, source, config, token, loc, fixRange, replacementPath, sourcePath) {
+  if (!shouldReport(token, config)) return;
+  const suffix = modifierSuffix(token, sourcePath);
+  const suggestions = config.suggestSemanticTokens(token.path).slice(0, MAX_SUGGESTIONS);
+  const descriptor = {
+    messageId: "primitive",
+    data: { category: token.category, token: token.categoryPath },
+    loc: toEslintLoc(loc)
+  };
+  if (source && fixRange && suggestions.length > 0) {
+    descriptor.suggest = suggestions.map((suggestion) => {
+      const replacement = replacementPath(suggestion, suffix);
+      return {
+        desc: `Use the semantic token "${replacement}"`,
+        fix: (fixer) => fixer.replaceTextRange(fixRange, replacementForRange(source, fixRange, replacement))
+      };
+    });
+  }
+  context.report(descriptor);
+}
+function reportStyleEntries(context, inspection, config, source) {
+  for (const entry of inspection.styleEntries) {
+    if (entry.kind !== "utility") continue;
+    for (const leaf of entry.valueSpans ?? []) {
+      if (!leaf.token) continue;
+      const fixRange = source ? [byteToIndex(source, leaf.span.start), byteToIndex(source, leaf.span.end)] : void 0;
+      reportPrimitiveToken(context, source, config, leaf.token, entry.range, fixRange, (suggestion, suffix) => {
+        return `${suggestion.token}${suffix}`;
+      });
+    }
+  }
+}
+function reportTokenRefs(context, inspection, config, source) {
+  for (const tokenRef of inspection.tokenRefs) {
+    if (!tokenRef.resolved || !tokenRef.token) continue;
+    const sourcePath = source ? tokenRefSourcePath(source, tokenRef.span, tokenRef.path) : tokenRef.path;
+    const fixRange = source ? tokenRefFixRange(source, tokenRef.span, sourcePath) : void 0;
+    reportPrimitiveToken(
+      context,
+      source,
+      config,
+      tokenRef.token,
+      tokenRef.range,
+      fixRange,
+      (suggestion, suffix) => `${tokenRef.token?.category}.${suggestion.token}${suffix}`,
+      sourcePath
+    );
+  }
+}
+function reportPrimitiveTokenViolations(context, inspection, config) {
+  const source = getSourceText(context);
+  reportStyleEntries(context, inspection, config, source);
+  reportTokenRefs(context, inspection, config, source);
+}
+function createNoPrimitiveTokenRule(options) {
+  return {
+    meta: {
+      type: "suggestion",
+      docs: { description: "Prefer semantic tokens over primitive tokens when semantic tokens exist for a category." },
+      schema: [
+        {
+          type: "object",
+          properties: {
+            categories: { type: "array", items: { type: "string" }, uniqueItems: true },
+            allow: { type: "array", items: { type: "string" }, uniqueItems: true }
+          },
+          additionalProperties: false
+        }
+      ],
+      messages: {
+        primitive: 'Use a semantic {{category}} token instead of the primitive token "{{token}}".'
+      },
+      hasSuggestions: true
+    },
+    create(context) {
+      const configured = context.options?.[0];
+      const categories = configured?.categories ? new Set(configured.categories) : void 0;
+      const allow = new Set(configured?.allow ?? []);
+      return {
+        Program() {
+          const inspection = options.inspect(context);
+          if (!inspection) return;
+          reportPrimitiveTokenViolations(context, inspection, { ...options, categories, allow });
+        }
+      };
+    }
+  };
+}
+
+// src/rules/no-margin-properties.ts
+var noMarginPropertiesRuleName = "no-margin-properties";
+var MESSAGE4 = "Avoid margin properties; prefer `gap` or a layout pattern for spacing.";
+function createNoMarginPropertiesRule(options) {
+  return {
+    meta: {
+      type: "suggestion",
+      docs: { description: "Disallow margin properties in favor of gap/layout patterns." },
+      schema: [],
+      messages: { margin: MESSAGE4 }
+    },
+    create(context) {
+      return {
+        Program() {
+          const inspection = options.inspect(context);
+          if (!inspection) return;
+          for (const entry of inspection.styleEntries) {
+            if (entry.kind !== "utility") continue;
+            const prop = entry.canonicalName ?? entry.name;
+            if (prop.startsWith("margin")) {
+              context.report({ messageId: "margin", loc: toEslintLoc(entry.range) });
+            }
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/rules/no-physical-properties.ts
+var noPhysicalPropertiesRuleName = "no-physical-properties";
+var PHYSICAL = {
+  left: "insetInlineStart",
+  right: "insetInlineEnd",
+  top: "insetBlockStart",
+  bottom: "insetBlockEnd",
+  marginLeft: "marginInlineStart",
+  marginRight: "marginInlineEnd",
+  marginTop: "marginBlockStart",
+  marginBottom: "marginBlockEnd",
+  paddingLeft: "paddingInlineStart",
+  paddingRight: "paddingInlineEnd",
+  paddingTop: "paddingBlockStart",
+  paddingBottom: "paddingBlockEnd",
+  borderLeft: "borderInlineStart",
+  borderRight: "borderInlineEnd",
+  borderTop: "borderBlockStart",
+  borderBottom: "borderBlockEnd",
+  borderLeftWidth: "borderInlineStartWidth",
+  borderRightWidth: "borderInlineEndWidth",
+  borderTopWidth: "borderBlockStartWidth",
+  borderBottomWidth: "borderBlockEndWidth",
+  borderTopLeftRadius: "borderStartStartRadius",
+  borderTopRightRadius: "borderStartEndRadius",
+  borderBottomLeftRadius: "borderEndStartRadius",
+  borderBottomRightRadius: "borderEndEndRadius"
+};
+function createNoPhysicalPropertiesRule(options) {
+  return {
+    meta: {
+      type: "suggestion",
+      docs: { description: "Disallow physical properties that have logical equivalents." },
+      schema: [],
+      messages: { physical: 'Use the logical property "{{logical}}" instead of the physical "{{physical}}".' }
+    },
+    create(context) {
+      return {
+        Program() {
+          const inspection = options.inspect(context);
+          if (!inspection) return;
+          for (const entry of inspection.styleEntries) {
+            if (entry.kind !== "utility") continue;
+            const prop = entry.canonicalName ?? entry.name;
+            const logical = PHYSICAL[prop];
+            if (logical === void 0) continue;
+            context.report({
+              messageId: "physical",
+              data: { logical, physical: prop },
+              loc: toEslintLoc(entry.range)
+            });
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/rules/no-shorthand-longhand-mix.ts
+var noShorthandLonghandMixRuleName = "no-shorthand-longhand-mix";
+var COMPOSITE_PROPERTIES = {
+  animation: [
+    "animationName",
+    "animationDuration",
+    "animationTimingFunction",
+    "animationDelay",
+    "animationIterationCount",
+    "animationDirection",
+    "animationFillMode",
+    "animationPlayState"
+  ],
+  background: [
+    "backgroundImage",
+    "backgroundPosition",
+    "backgroundSize",
+    "backgroundRepeat",
+    "backgroundAttachment",
+    "backgroundOrigin",
+    "backgroundClip",
+    "backgroundColor"
+  ],
+  backgroundPosition: ["backgroundPositionX", "backgroundPositionY"],
+  border: ["borderWidth", "borderStyle", "borderColor"],
+  borderBlock: ["borderBlockWidth", "borderBlockStyle", "borderBlockColor"],
+  borderBlockColor: ["borderBlockStartColor", "borderBlockEndColor"],
+  borderBlockEnd: ["borderBlockEndWidth", "borderBlockEndStyle", "borderBlockEndColor"],
+  borderBlockStart: ["borderBlockStartWidth", "borderBlockStartStyle", "borderBlockStartColor"],
+  borderBlockStyle: ["borderBlockStartStyle", "borderBlockEndStyle"],
+  borderBlockWidth: ["borderBlockStartWidth", "borderBlockEndWidth"],
+  borderBottom: ["borderBottomWidth", "borderBottomStyle", "borderBottomColor"],
+  borderColor: ["borderTopColor", "borderRightColor", "borderBottomColor", "borderLeftColor"],
+  borderImage: ["borderImageSource", "borderImageSlice", "borderImageWidth", "borderImageOutset", "borderImageRepeat"],
+  borderInline: ["borderInlineWidth", "borderInlineStyle", "borderInlineColor"],
+  borderInlineColor: ["borderInlineStartColor", "borderInlineEndColor"],
+  borderInlineEnd: ["borderInlineEndWidth", "borderInlineEndStyle", "borderInlineEndColor"],
+  borderInlineStart: ["borderInlineStartWidth", "borderInlineStartStyle", "borderInlineStartColor"],
+  borderInlineStyle: ["borderInlineStartStyle", "borderInlineEndStyle"],
+  borderInlineWidth: ["borderInlineStartWidth", "borderInlineEndWidth"],
+  borderLeft: ["borderLeftWidth", "borderLeftStyle", "borderLeftColor"],
+  borderRadius: ["borderTopLeftRadius", "borderTopRightRadius", "borderBottomRightRadius", "borderBottomLeftRadius"],
+  borderRight: ["borderRightWidth", "borderRightStyle", "borderRightColor"],
+  borderStyle: ["borderTopStyle", "borderRightStyle", "borderBottomStyle", "borderLeftStyle"],
+  borderTop: ["borderTopWidth", "borderTopStyle", "borderTopColor"],
+  borderWidth: ["borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth"],
+  columnRule: ["columnRuleWidth", "columnRuleStyle", "columnRuleColor"],
+  columns: ["columnWidth", "columnCount"],
+  containIntrinsicSize: ["containIntrinsicSizeInline", "containIntrinsicSizeBlock"],
+  flex: ["flexGrow", "flexShrink", "flexBasis"],
+  flexFlow: ["flexDirection", "flexWrap"],
+  font: [
+    "fontStyle",
+    "fontVariantCaps",
+    "fontVariantEastAsian",
+    "fontVariantLigatures",
+    "fontVariantNumeric",
+    "fontVariantPosition",
+    "fontWeight",
+    "fontStretch",
+    "fontSize",
+    "lineHeight",
+    "fontFamily"
+  ],
+  fontSynthesis: ["fontSynthesisWeight", "fontSynthesisStyle", "fontSynthesisSmallCaps"],
+  fontVariant: [
+    "fontVariantCaps",
+    "fontVariantEastAsian",
+    "fontVariantLigatures",
+    "fontVariantNumeric",
+    "fontVariantPosition"
+  ],
+  gap: ["columnGap", "rowGap"],
+  grid: [
+    "gridTemplateColumns",
+    "gridTemplateRows",
+    "gridTemplateAreas",
+    "gridAutoColumns",
+    "gridAutoRows",
+    "gridAutoFlow"
+  ],
+  gridArea: ["gridRowStart", "gridColumnStart", "gridRowEnd", "gridColumnEnd"],
+  gridColumn: ["gridColumnStart", "gridColumnEnd"],
+  gridGap: ["gridColumnGap", "gridRowGap"],
+  gridRow: ["gridRowStart", "gridRowEnd"],
+  gridTemplate: ["gridTemplateColumns", "gridTemplateRows", "gridTemplateAreas"],
+  inset: ["top", "right", "bottom", "left"],
+  insetBlock: ["insetBlockStart", "insetBlockEnd"],
+  insetInline: ["insetInlineStart", "insetInlineEnd"],
+  listStyle: ["listStyleType", "listStylePosition", "listStyleImage"],
+  margin: ["marginTop", "marginRight", "marginBottom", "marginLeft"],
+  marginBlock: ["marginBlockStart", "marginBlockEnd"],
+  marginInline: ["marginInlineStart", "marginInlineEnd"],
+  mask: ["maskImage", "maskMode", "maskRepeat", "maskPosition", "maskClip", "maskOrigin", "maskSize", "maskComposite"],
+  maskBorder: [
+    "maskBorderSource",
+    "maskBorderMode",
+    "maskBorderSlice",
+    "maskBorderWidth",
+    "maskBorderOutset",
+    "maskBorderRepeat"
+  ],
+  offset: ["offsetPosition", "offsetPath", "offsetDistance", "offsetRotate", "offsetAnchor"],
+  outline: ["outlineWidth", "outlineStyle", "outlineColor"],
+  overflow: ["overflowX", "overflowY"],
+  padding: ["paddingTop", "paddingRight", "paddingBottom", "paddingLeft"],
+  paddingBlock: ["paddingBlockStart", "paddingBlockEnd"],
+  paddingInline: ["paddingInlineStart", "paddingInlineEnd"],
+  placeContent: ["alignContent", "justifyContent"],
+  placeItems: ["alignItems", "justifyItems"],
+  placeSelf: ["alignSelf", "justifySelf"],
+  scrollMargin: ["scrollMarginTop", "scrollMarginRight", "scrollMarginBottom", "scrollMarginLeft"],
+  scrollMarginBlock: ["scrollMarginBlockStart", "scrollMarginBlockEnd"],
+  scrollMarginInline: ["scrollMarginInlineStart", "scrollMarginInlineEnd"],
+  scrollPadding: ["scrollPaddingTop", "scrollPaddingRight", "scrollPaddingBottom", "scrollPaddingLeft"],
+  scrollPaddingBlock: ["scrollPaddingBlockStart", "scrollPaddingBlockEnd"],
+  scrollPaddingInline: ["scrollPaddingInlineStart", "scrollPaddingInlineEnd"],
+  textDecoration: ["textDecorationLine", "textDecorationStyle", "textDecorationColor"],
+  textEmphasis: ["textEmphasisStyle", "textEmphasisColor"],
+  transition: ["transitionProperty", "transitionDuration", "transitionTimingFunction", "transitionDelay"]
+};
+function createNoShorthandLonghandMixRule(options) {
+  return {
+    meta: {
+      type: "suggestion",
+      docs: { description: "Disallow mixing a shorthand property with its longhand pieces in the same style block." },
+      schema: [
+        {
+          type: "object",
+          properties: { ignore: { type: "array", items: { type: "string" }, uniqueItems: true } },
+          additionalProperties: false
+        }
+      ],
+      messages: {
+        mix: '"{{shorthand}}" is mixed with {{longhands}}. Panda emits longhands after shorthands, so {{longhands}} will win regardless of source order; use the longhand properties for a predictable result.'
+      }
+    },
+    create(context) {
+      const configured = context.options?.[0];
+      const ignore = new Set(configured?.ignore ?? []);
+      return {
+        Program() {
+          const inspection = options.inspect(context);
+          if (!inspection) return;
+          const groups = /* @__PURE__ */ new Map();
+          for (const entry of inspection.styleEntries) {
+            if (entry.kind !== "utility") continue;
+            const parent = entry.path.slice(0, -1).join(".");
+            const key = [entry.owner.kind, entry.owner.index, parent].join("|");
+            const group = groups.get(key) ?? /* @__PURE__ */ new Map();
+            group.set(entry.canonicalName ?? entry.name, entry);
+            groups.set(key, group);
+          }
+          for (const group of groups.values()) {
+            for (const [prop, entry] of group) {
+              if (ignore.has(prop)) continue;
+              const pieces = COMPOSITE_PROPERTIES[prop];
+              if (!pieces) continue;
+              const mixed = pieces.filter((piece) => group.has(piece));
+              if (mixed.length === 0) continue;
+              const list = mixed.map((piece) => `"${piece}"`).join(", ");
+              context.report({
+                messageId: "mix",
+                data: { shorthand: prop, longhands: list },
+                loc: toEslintLoc(entry.range)
+              });
+            }
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/rules/prefer-token.ts
+var preferTokenRuleName = "prefer-token";
+var MAX_LISTED = 3;
+function collectStrings(value, out) {
+  if (typeof value === "string") out.push(value);
+  else if (Array.isArray(value)) for (const item of value) collectStrings(item, out);
+  else if (value && typeof value === "object") for (const item of Object.values(value)) collectStrings(item, out);
+}
+var label = (s) => s.conditional ? `${s.token} (themed)` : s.token;
+function reportTokenViolations(context, inspection, config) {
+  const source = getSourceText(context);
+  for (const entry of inspection.styleEntries) {
+    if (entry.kind !== "utility") continue;
+    const category = config.categoryOf(entry.canonicalName ?? entry.name);
+    if (!category) continue;
+    if (config.categories && !config.categories.has(category)) continue;
+    const values = [];
+    collectStrings(entry.resolvedValue, values);
+    const hit = values.find((value) => !config.allow.has(value.trim()) && config.isHardcodedValue(entry.name, value));
+    if (hit === void 0) continue;
+    const suggestions = config.suggest(entry.name, hit).slice(0, MAX_LISTED);
+    const descriptor = suggestions.length ? {
+      messageId: "listed",
+      data: { category, value: hit, tokens: suggestions.map(label).join(", ") },
+      loc: toEslintLoc(entry.range)
+    } : { messageId: "generic", data: { category, value: hit }, loc: toEslintLoc(entry.range) };
+    const leaf = entry.valueSpans?.find((v) => v.value === hit);
+    if (suggestions.length > 0 && leaf && source) {
+      const range = [byteToIndex(source, leaf.span.start), byteToIndex(source, leaf.span.end)];
+      descriptor.suggest = suggestions.map((s) => ({
+        desc: `Use the token "${s.token}"`,
+        fix: (fixer) => fixer.replaceTextRange(range, `'${s.token}'`)
+      }));
+    }
+    context.report(descriptor);
+  }
+}
+function createPreferTokenRule(options) {
+  return {
+    meta: {
+      type: "suggestion",
+      docs: { description: "Prefer design tokens over hardcoded values on token-backed properties." },
+      schema: [
+        {
+          type: "object",
+          properties: {
+            categories: { type: "array", items: { type: "string" }, uniqueItems: true },
+            allow: { type: "array", items: { type: "string" }, uniqueItems: true }
+          },
+          additionalProperties: false
+        }
+      ],
+      messages: {
+        listed: 'Hardcoded {{category}} value "{{value}}". Matching tokens: {{tokens}}.',
+        generic: 'Use a {{category}} token instead of the hardcoded value "{{value}}".'
+      },
+      hasSuggestions: true
+    },
+    create(context) {
+      const configured = context.options?.[0];
+      const categories = configured?.categories ? new Set(configured.categories) : void 0;
+      const allow = new Set(configured?.allow ?? []);
+      return {
+        Program() {
+          const inspection = options.inspect(context);
+          if (!inspection) return;
+          reportTokenViolations(context, inspection, {
+            categoryOf: options.categoryOf,
+            isHardcodedValue: options.isHardcodedValue,
+            suggest: options.suggest,
+            categories,
+            allow
+          });
+        }
+      };
+    }
+  };
+}
+
+// src/rules/prefer-text-style.ts
+var preferTextStyleRuleName = "prefer-text-style";
+var MESSAGE5 = "Multiple typography properties set together; prefer a `textStyle` token.";
+var TYPOGRAPHY = /* @__PURE__ */ new Set([
+  "fontSize",
+  "fontWeight",
+  "lineHeight",
+  "letterSpacing",
+  "fontFamily",
+  "textDecoration",
+  "textTransform",
+  "fontStyle"
+]);
+function clustersTextStyle(value) {
+  if (Array.isArray(value)) return value.some(clustersTextStyle);
+  if (value && typeof value === "object") {
+    const obj = value;
+    const count = Object.keys(obj).filter((key) => TYPOGRAPHY.has(key)).length;
+    if (count >= 2) return true;
+    return Object.values(obj).some(clustersTextStyle);
+  }
+  return false;
+}
+function createPreferTextStyleRule(options) {
+  return {
+    meta: {
+      type: "suggestion",
+      docs: { description: "Prefer a `textStyle` token over multiple typography properties." },
+      schema: [],
+      messages: { textStyle: MESSAGE5 }
+    },
+    create(context) {
+      return {
+        Program() {
+          const inspection = options.inspect(context);
+          if (!inspection) return;
+          const report2 = (range) => context.report({ messageId: "textStyle", loc: toEslintLoc(range) });
+          for (const call of inspection.calls) {
+            if (call.data.some((arg) => clustersTextStyle(arg.value))) report2(call.range);
+          }
+          for (const jsx of inspection.jsx) {
+            if (clustersTextStyle(jsx.data)) report2(jsx.range);
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/plugin.ts
+import { SpecIndex } from "@pandacss/compiler/tooling";
+
+// package.json
+var package_default = {
+  name: "@pandacss/eslint-plugin",
+  version: "2.0.0-beta.11",
+  description: "ESLint rules for Panda CSS",
+  keywords: [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "panda",
+    "pandacss",
+    "css-in-js"
+  ],
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      source: "./src/index.ts",
+      types: "./dist/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./oxlint": {
+      source: "./src/oxlint.ts",
+      types: "./dist/oxlint.d.ts",
+      default: "./dist/oxlint.js"
+    },
+    "./package.json": "./package.json"
+  },
+  author: "Segun Adebayo <joseshegs@gmail.com>",
+  license: "MIT",
+  sideEffects: false,
+  homepage: "https://panda-css.com",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/chakra-ui/panda.git",
+    directory: "packages/eslint-plugin"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsup src/index.ts src/oxlint.ts --format=esm --platform=node --dts",
+    "build:fast": "tsup src/index.ts src/oxlint.ts --format=esm --platform=node --no-dts",
+    dev: "pnpm build:fast --watch",
+    test: "vitest run"
+  },
+  files: [
+    "dist"
+  ],
+  dependencies: {
+    "@pandacss/compiler": "workspace:*",
+    "@pandacss/compiler-shared": "workspace:*",
+    "@pandacss/config": "workspace:*"
+  },
+  devDependencies: {
+    "@typescript-eslint/parser": "8.58.2",
+    eslint: "9.39.1"
+  },
+  peerDependencies: {
+    eslint: ">=9"
+  },
+  engines: {
+    node: ">=22"
+  }
+};
+
+// src/plugin.ts
+var pluginMeta = { name: "@pandacss/eslint-plugin", version: package_default.version };
+var DOCS_URL = "https://github.com/chakra-ui/panda/blob/main/packages/eslint-plugin/README.md#rules";
+async function loadPandaProject(options = {}) {
+  const linter = options.linter ?? new Linter();
+  const project = await linter.getProject({
+    cwd: options.cwd ?? process.cwd(),
+    settings: options.configPath ? { panda: { configPath: options.configPath } } : {}
+  });
+  return { linter, project };
+}
+var RAW_VALUE_KEYWORDS = /* @__PURE__ */ new Set([
+  "inherit",
+  "initial",
+  "unset",
+  "revert",
+  "revert-layer",
+  "none",
+  "auto",
+  "currentcolor",
+  "transparent"
+]);
+function hardcodedValueClassifier(compiler) {
+  const cache = /* @__PURE__ */ new Map();
+  return (prop, value) => {
+    const key = `${prop}\0${value}`;
+    const cached = cache.get(key);
+    if (cached !== void 0) return cached;
+    let result = false;
+    if (!RAW_VALUE_KEYWORDS.has(value.trim().toLowerCase())) {
+      const resolved = compiler.resolveUtilityValue({ prop, value });
+      result = resolved !== null && !String(resolved.cssValue).trimStart().startsWith("var(");
+    }
+    cache.set(key, result);
+    return result;
+  };
+}
+function recipeDeprecations(spec) {
+  const out = {};
+  for (const recipe of Object.values(spec.recipes)) {
+    if (recipe.deprecated !== void 0) out[recipe.name] = recipe.deprecated;
+  }
+  for (const recipe of Object.values(spec.slotRecipes)) {
+    if (recipe.deprecated !== void 0) out[recipe.name] = recipe.deprecated;
+  }
+  return out;
+}
+function patternDeprecations(spec) {
+  const out = {};
+  for (const pattern of Object.values(spec.patterns)) {
+    if (pattern.deprecated !== void 0) out[pattern.name] = pattern.deprecated;
+  }
+  return out;
+}
+function bindRules(linter, project) {
+  const spec = project.compiler.spec();
+  const specIndex = new SpecIndex(spec);
+  const categoryOf = (prop) => specIndex.resolveTokenCategoryForProperty(prop);
+  const isHardcodedValue = hardcodedValueClassifier(project.compiler);
+  const suggest = (prop, value) => project.compiler.suggestTokens(prop, value);
+  const suggestSemanticTokens = (path) => project.compiler.suggestSemanticTokens(path);
+  const inspect = (context) => linter.inspectProject(project, getContextFilename(context), getContextSource(context));
+  const rules = {
+    [extractionDiagnosticsRuleName]: createExtractionDiagnosticsRule({ inspect }),
+    [fileNotIncludedRuleName]: createFileNotIncludedRule({
+      inspect,
+      isSourceFile: (path) => project.compiler.isSourceFile(path)
+    }),
+    [noInvalidTokenPathsRuleName]: createNoInvalidTokenPathsRule({ inspect }),
+    [noInvalidNestingRuleName]: createNoInvalidNestingRule({ inspect }),
+    [noDeprecatedRuleName]: createNoDeprecatedRule({
+      inspect,
+      tokens: spec.tokens.deprecated,
+      utilities: spec.utilities.deprecated,
+      recipes: recipeDeprecations(spec),
+      patterns: patternDeprecations(spec)
+    }),
+    [noDebugRuleName]: createNoDebugRule({ inspect }),
+    // `recommended` scopes prefer-token to colors (the old `no-hardcoded-color`).
+    [preferTokenRuleName]: createPreferTokenRule({ inspect, categoryOf, isHardcodedValue, suggest }),
+    [noPrimitiveTokenRuleName]: createNoPrimitiveTokenRule({ inspect, suggestSemanticTokens }),
+    // Opt-in style/enforcement rules (not in `recommended`).
+    [noImportantRuleName]: createNoImportantRule({ inspect }),
+    [noMarginPropertiesRuleName]: createNoMarginPropertiesRule({ inspect }),
+    [noPhysicalPropertiesRuleName]: createNoPhysicalPropertiesRule({ inspect }),
+    [noShorthandLonghandMixRuleName]: createNoShorthandLonghandMixRule({ inspect }),
+    [consistentPropertyStyleRuleName]: createConsistentPropertyStyleRule({
+      inspect,
+      shorthands: spec.utilities.shorthands
+    }),
+    [preferTextStyleRuleName]: createPreferTextStyleRule({ inspect })
+  };
+  for (const rule of Object.values(rules)) {
+    rule.meta.docs.url = DOCS_URL;
+  }
+  return rules;
+}
+async function createPandaPlugin(options = {}) {
+  const { linter, project } = await loadPandaProject(options);
+  return { rules: bindRules(linter, project) };
+}
+
+export {
+  getSourceText,
+  byteToIndex,
+  toEslintLoc,
+  consistentPropertyStyleRuleName,
+  createConsistentPropertyStyleRule,
+  extractionDiagnosticsRuleName,
+  createExtractionDiagnosticsRule,
+  reportDiagnostics,
+  noInvalidTokenPathsRuleName,
+  createNoInvalidTokenPathsRule,
+  FileInspector,
+  sourceCacheKey,
+  ProjectCache,
+  projectCacheKey,
+  resolvePandaSettings,
+  Linter,
+  getContextFilename,
+  getContextSource,
+  fileNotIncludedRuleName,
+  createFileNotIncludedRule,
+  noDebugRuleName,
+  createNoDebugRule,
+  noDeprecatedRuleName,
+  createNoDeprecatedRule,
+  noImportantRuleName,
+  createNoImportantRule,
+  noInvalidNestingRuleName,
+  createNoInvalidNestingRule,
+  noPrimitiveTokenRuleName,
+  reportPrimitiveTokenViolations,
+  createNoPrimitiveTokenRule,
+  noMarginPropertiesRuleName,
+  createNoMarginPropertiesRule,
+  noPhysicalPropertiesRuleName,
+  createNoPhysicalPropertiesRule,
+  noShorthandLonghandMixRuleName,
+  createNoShorthandLonghandMixRule,
+  preferTokenRuleName,
+  collectStrings,
+  reportTokenViolations,
+  createPreferTokenRule,
+  preferTextStyleRuleName,
+  createPreferTextStyleRule,
+  pluginMeta,
+  loadPandaProject,
+  bindRules,
+  createPandaPlugin
+};