@nadicodeai/ui 12.1.165 → 12.1.167

package/dist/eslint/rules/disabled-control-appearance.js

@@ -1,75 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match a
- * conditional `variant`, but not that its condition reads a value the same
- * element's `disabled` reads. That needs the two expressions compared.
- */
-
-import { walk } from "./rendered-import.js";
-
-const APPEARANCE_ATTRIBUTES = ["variant", "triggerVariant", "size"];
-
-function valuePathsAndPrefixes(root, sourceCode) {
-  const names = new Set();
-  const collect = (node) => {
-    const pathTail = node.parent?.type === "MemberExpression" && !node.parent.computed;
-    if (node.type === "Identifier" && !pathTail) names.add(node.name);
-    if (node.type === "MemberExpression" && !node.computed) names.add(sourceCode.getText(node));
-  };
-  collect(root);
-  walk(root, sourceCode.visitorKeys, collect);
-  return names;
-}
-
-const attribute = (openingElement, name) =>
-  openingElement.attributes.find(
-    (candidate) => candidate.type === "JSXAttribute" && candidate.name.name === name,
-  );
-
-export const disabledControlAppearance = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A control never chooses its variant from the condition that disables it, so a disabled control has one appearance.",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          controls: { type: "array", items: { type: "string" }, uniqueItems: true },
-        },
-        additionalProperties: false,
-      },
-    ],
-    defaultOptions: [{ controls: ["Button"] }],
-    messages: {
-      "variant-follows-disabled":
-        "{{control}} turns its {{attribute}} on `{{condition}}`, which also disables it, so its disabled state looks unlike every other disabled {{control}}. Keep one {{attribute}} and let `disabled` draw the state.",
-    },
-  },
-  create(context) {
-    const [{ controls }] = context.options;
-    const { sourceCode } = context;
-    return {
-      JSXOpeningElement(node) {
-        if (node.name.type !== "JSXIdentifier" || !controls.includes(node.name.name)) return;
-        const disabled = attribute(node, "disabled")?.value;
-        if (disabled?.type !== "JSXExpressionContainer") return;
-        const disabling = valuePathsAndPrefixes(disabled.expression, sourceCode);
-        for (const name of APPEARANCE_ATTRIBUTES) {
-          const chosen = attribute(node, name)?.value;
-          if (chosen?.type !== "JSXExpressionContainer") continue;
-          if (chosen.expression.type !== "ConditionalExpression") continue;
-          const { test } = chosen.expression;
-          if (![...valuePathsAndPrefixes(test, sourceCode)].some((read) => disabling.has(read)))
-            continue;
-          context.report({
-            node: chosen,
-            messageId: "variant-follows-disabled",
-            data: { control: node.name.name, attribute: name, condition: sourceCode.getText(test) },
-          });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/ellipsis-opens-a-dialog.js

@@ -1,110 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-syntax` can match a label that
- * ends in an ellipsis, but not what its command does: whether the handler
- * opens something (a call that opens or passes `true`), runs, or navigates.
- */
-import { childText, keyName, literalText } from "./literal-text.js";
-import { renderedImports } from "./rendered-import.js";
-
-const ENDS_IN_ELLIPSIS = /(?:…|\.\.\.)\s*$/;
-const COMMAND_KEYS = new Set(["onClick", "onSelect", "link", "render", "icon"]);
-const HANDLER_KEYS = new Set(["onClick", "onSelect"]);
-const MENU_ROWS = new Set([
-  "DropdownMenuItem",
-  "DropdownMenuCommand",
-  "ContextMenuItem",
-  "MenubarItem",
-]);
-const MENU_LINKS = new Set(["DropdownMenuLink", "ContextMenuLink"]);
-const FROM_DESIGN_SYSTEM = /^(@nadicodeai\/ui(\/|$)|@\/|\.)/;
-const OPENING_CALL = /^(?:open|show)(?:[A-Z]|$)/;
-const FUNCTIONS = new Set(["ArrowFunctionExpression", "FunctionExpression"]);
-
-const calleeName = (callee) => {
-  if (callee.type === "Identifier") return callee.name;
-  if (callee.type === "MemberExpression" && !callee.computed) return callee.property.name;
-  return null;
-};
-
-function opensSomething(node, visitorKeys) {
-  const calls = [];
-  const stack = [node.body];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    if (current.type === "CallExpression") calls.push(current);
-    for (const key of visitorKeys[current.type] ?? []) {
-      const value = current[key];
-      for (const child of Array.isArray(value) ? value : [value]) {
-        if (child?.type) stack.push(child);
-      }
-    }
-  }
-  return calls.some(
-    (call) =>
-      OPENING_CALL.test(calleeName(call.callee) ?? "") ||
-      call.arguments.some((argument) => argument.type === "Literal" && argument.value === true),
-  );
-}
-
-export const ellipsisOpensADialog = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "A command's label ends in an ellipsis only when the command opens a dialog.",
-    },
-    schema: [],
-    messages: {
-      "ellipsis-without-dialog":
-        'An ellipsis says "this asks for more before it acts". "{{label}}" navigates or runs at once, so drop the ellipsis; keep it only on a command that opens a dialog.',
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const { visitorKeys } = context.sourceCode;
-
-    function reportsNoDialog(handler) {
-      return (
-        handler !== undefined &&
-        FUNCTIONS.has(handler.type) &&
-        !opensSomething(handler, visitorKeys)
-      );
-    }
-
-    return {
-      ObjectExpression(node) {
-        const keys = new Map(node.properties.map((property) => [keyName(property), property]));
-        const label = literalText(keys.get("label")?.value);
-        if (label === null || !ENDS_IN_ELLIPSIS.test(label)) return;
-        if (![...keys.keys()].some((key) => COMMAND_KEYS.has(key))) return;
-        if (keys.has("render")) return;
-        const handlerProperty = [...keys].find(([key]) => HANDLER_KEYS.has(key))?.[1];
-        const navigates = keys.has("link");
-        if (navigates || reportsNoDialog(handlerProperty?.value)) {
-          context.report({
-            node: keys.get("label").value,
-            messageId: "ellipsis-without-dialog",
-            data: { label },
-          });
-        }
-      },
-      JSXElement(node) {
-        const imported = importOf(node.openingElement.name);
-        if (!imported || !FROM_DESIGN_SYSTEM.test(imported.source)) return;
-        const row = MENU_ROWS.has(imported.name);
-        if (!row && !MENU_LINKS.has(imported.name)) return;
-        const label = childText(node);
-        if (label === null || !ENDS_IN_ELLIPSIS.test(label)) return;
-        const handler = node.openingElement.attributes.find(
-          (attribute) => attribute.type === "JSXAttribute" && HANDLER_KEYS.has(attribute.name.name),
-        )?.value?.expression;
-        if (!row || reportsNoDialog(handler)) {
-          context.report({
-            node: node.openingElement,
-            messageId: "ellipsis-without-dialog",
-            data: { label },
-          });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/empty-state-owner.js

@@ -1,145 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match
- * `items.length === 0 ? <X/> : …`, but not which branch is the empty one once
- * the test is turned around (`items.length > 0 ? <List/> : <p/>`, an early
- * `if` whose empty branch is the next `return`), so it would either miss those
- * or report the list branch.
- */
-import { renderedImports } from "./rendered-import.js";
-
-const OWNERS = [
-  "EmptyState",
-  "CollectionPage",
-  "RecordList",
-  "ActivityFeed",
-  "LibraryShelf",
-  "CatalogDrawer",
-  "DataTable",
-  "CommandEmpty",
-  "ComboboxEmpty",
-];
-
-const SIZE_PROPERTIES = new Set(["length", "size"]);
-const COUNT = /^count$|[a-z0-9]Count$/;
-
-const unwrapChain = (node) => (node.type === "ChainExpression" ? node.expression : node);
-
-const isSize = (node) => {
-  const read = unwrapChain(node);
-  if (read.type === "Identifier") return COUNT.test(read.name);
-  if (read.type !== "MemberExpression" || read.computed) return false;
-  return SIZE_PROPERTIES.has(read.property.name) || COUNT.test(read.property.name);
-};
-
-const MIRRORED = { "<": ">", ">": "<", "<=": ">=", ">=": "<=" };
-
-const EMPTY_WHEN = {
-  "===": { 0: "empty" },
-  "==": { 0: "empty" },
-  "!==": { 0: "present" },
-  "!=": { 0: "present" },
-  "<": { 1: "empty" },
-  "<=": { 0: "empty" },
-  ">": { 0: "present" },
-  ">=": { 1: "present" },
-};
-
-function emptiness(test) {
-  const node = unwrapChain(test);
-  if (isSize(node)) return "present";
-  if (node.type === "UnaryExpression" && node.operator === "!") {
-    const inner = emptiness(node.argument);
-    if (inner === "empty") return "present";
-    if (inner === "present") return "empty";
-    return null;
-  }
-  if (node.type === "LogicalExpression") {
-    const sides = [emptiness(node.left), emptiness(node.right)];
-    if (node.operator === "&&" && sides.includes("empty")) return "empty";
-    if (node.operator === "||" && sides.includes("present")) return "present";
-    return null;
-  }
-  if (node.type !== "BinaryExpression") return null;
-  let { operator, left, right } = node;
-  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- ESTree types Literal.value as string | number | boolean | RegExp | bigint | null; only typeof picks the number.
-  if (isSize(right) && typeof left.value === "number") {
-    [left, right] = [right, left];
-    operator = MIRRORED[operator] ?? operator;
-  }
-  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- ESTree types Literal.value as string | number | boolean | RegExp | bigint | null; only typeof picks the number.
-  if (!isSize(left) || typeof right.value !== "number") return null;
-  return EMPTY_WHEN[operator]?.[right.value] ?? null;
-}
-
-function returned(statement) {
-  if (!statement) return null;
-  if (statement.type === "ReturnStatement") return statement.argument;
-  if (statement.type === "BlockStatement") {
-    const found = statement.body.find((inner) => inner.type === "ReturnStatement");
-    return found?.argument ?? null;
-  }
-  return null;
-}
-
-function nextStatement(statement) {
-  const body = statement.parent.body;
-  if (!Array.isArray(body)) return null;
-  return body[body.indexOf(statement) + 1] ?? null;
-}
-
-export const emptyStateOwner = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "An absence renders EmptyState, or a composition that draws its own.",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          owners: { type: "array", items: { type: "string" }, uniqueItems: true },
-        },
-        additionalProperties: false,
-      },
-    ],
-    defaultOptions: [{ owners: [] }],
-    messages: {
-      "absence-branch":
-        "An absence is EmptyState: firstUse with the section's picture, nothingYet, noResults with its clear, or failed with its retry.",
-    },
-  },
-  create(context) {
-    const owners = new Set([...OWNERS, ...context.options[0].owners]);
-    const importOf = renderedImports(context);
-    const drawnByAnOwner = (element) =>
-      owners.has(importOf(element.openingElement.name)?.name ?? "");
-
-    function checkEmptyBranch(branch) {
-      const drawsItsOwn =
-        branch?.type === "JSXFragment" ||
-        (branch?.type === "JSXElement" && !drawnByAnOwner(branch));
-      if (drawsItsOwn) context.report({ node: branch, messageId: "absence-branch" });
-    }
-
-    return {
-      ConditionalExpression(node) {
-        const verdict = emptiness(node.test);
-        if (verdict === "empty") checkEmptyBranch(node.consequent);
-        else if (verdict === "present") checkEmptyBranch(node.alternate);
-      },
-      LogicalExpression(node) {
-        if (node.operator === "&&" && emptiness(node.left) === "empty") {
-          checkEmptyBranch(node.right);
-        }
-      },
-      IfStatement(node) {
-        const verdict = emptiness(node.test);
-        if (verdict === "empty") {
-          checkEmptyBranch(returned(node.consequent));
-        } else if (verdict === "present" && returned(node.consequent)) {
-          checkEmptyBranch(returned(node.alternate ?? nextStatement(node)));
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/input-group-owners.js

@@ -1,155 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match an
- * `InputGroupAddon` holding `<Search/>`, but not an element joined to its import
- * (a renamed or namespaced one), nor the shape of a whole group: only addons of
- * fixed text or one icon around one input, a group with another button, a
- * block addon or a textarea allowed. That needs the group's children together.
- */
-import {
-  PACKAGE_BARREL,
-  findBelow,
-  partOf,
-  renderedImports,
-  staticAttribute,
-  walk,
-} from "./rendered-import.js";
-
-const GROUP_PARTS = [
-  "InputGroup",
-  "InputGroupAddon",
-  "InputGroupButton",
-  "InputGroupInput",
-  "InputGroupText",
-  "InputGroupTextarea",
-];
-
-const GROUP_MODULES = [
-  "@nadicodeai/ui/components/input-group",
-  PACKAGE_BARREL,
-  "@/components/input-group",
-];
-
-const PARTS = new Map(
-  GROUP_PARTS.map((part) => [part, GROUP_MODULES.map((from) => ({ from, part }))]),
-);
-
-const ICON_MODULES = new Set(["lucide-react", "@nadicodeai/ui/components/house-icons"]);
-const SEARCH_ICONS = new Set(["Search", "SearchIcon"]);
-const CLEAR_ICONS = new Set(["X", "XIcon"]);
-const INLINE_ALIGNS = new Set(["inline-start", "inline-end"]);
-
-const significant = (element) =>
-  element.children.filter(
-    (child) =>
-      !(child.type === "JSXText" && child.value.trim() === "") &&
-      !(child.type === "JSXExpressionContainer" && child.expression.type === "JSXEmptyExpression"),
-  );
-
-const isFixedText = (child) =>
-  child.type === "JSXText" ||
-  (child.type === "JSXExpressionContainer" && child.expression.type === "Literal");
-
-export const inputGroupOwners = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A search box, a box that clears and fixed text or an icon in a box are drawn by the component that owns them, not by hand from InputGroup parts.",
-    },
-    schema: [],
-    messages: {
-      "hand-built-field":
-        "Use the component that owns this field: CollectionSearch for a collection's search, ClearableInput for a box that clears, Input's prefix and suffix for fixed text or an icon in the box.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const { visitorKeys } = context.sourceCode;
-
-    const partName = (element) =>
-      partOf(importOf(element.openingElement.name), PARTS, context.filename);
-
-    const iconName = (element) => {
-      const imported = importOf(element.openingElement.name);
-      return imported && ICON_MODULES.has(imported.source) ? imported.name : null;
-    };
-
-    const holdsIcon = (element, names) =>
-      findBelow(
-        element,
-        visitorKeys,
-        (node) => node.type === "JSXElement" && names.has(iconName(node)),
-      ) !== null;
-
-    function holdsTextOrOneIcon(element) {
-      const content = significant(element);
-      if (content.length === 0) return false;
-      if (content.length === 1 && content[0].type === "JSXElement") {
-        const [only] = content;
-        if (iconName(only)) return true;
-        return partName(only) === "InputGroupText" && holdsTextOrOneIcon(only);
-      }
-      return content.every(isFixedText);
-    }
-
-    function readGroup(group) {
-      const facts = {
-        inputs: 0,
-        hasTextarea: false,
-        hasBlockAddon: false,
-        hasSearchAddon: false,
-        hasClearButton: false,
-        hasOtherButton: false,
-      };
-      walk(group, visitorKeys, (node) => {
-        if (node.type !== "JSXElement") return true;
-        const part = partName(node);
-        if (part === "InputGroup") return false;
-        if (part === "InputGroupInput") facts.inputs += 1;
-        if (part === "InputGroupTextarea") facts.hasTextarea = true;
-        if (part === "InputGroupAddon") {
-          const { openingElement } = node;
-          const hasAlign = openingElement.attributes.some(
-            (attribute) => attribute.type === "JSXAttribute" && attribute.name.name === "align",
-          );
-          if (hasAlign && !INLINE_ALIGNS.has(staticAttribute(openingElement, "align"))) {
-            facts.hasBlockAddon = true;
-          }
-          if (holdsIcon(node, SEARCH_ICONS)) facts.hasSearchAddon = true;
-        }
-        if (part === "InputGroupButton") {
-          if (holdsIcon(node, CLEAR_ICONS)) facts.hasClearButton = true;
-          else facts.hasOtherButton = true;
-        }
-        return true;
-      });
-      return facts;
-    }
-
-    function isFixedAdornments(group) {
-      const children = significant(group);
-      if (!children.every((child) => child.type === "JSXElement")) return false;
-      const parts = children.map(partName);
-      const addons = children.filter((_, index) => parts[index] === "InputGroupAddon");
-      const inputs = parts.filter((part) => part === "InputGroupInput");
-      return (
-        inputs.length === 1 &&
-        addons.length > 0 &&
-        addons.length + inputs.length === children.length &&
-        addons.every(holdsTextOrOneIcon)
-      );
-    }
-
-    return {
-      JSXElement(node) {
-        if (partName(node) !== "InputGroup") return;
-        const facts = readGroup(node);
-        if (facts.hasTextarea || facts.hasBlockAddon || facts.hasOtherButton) return;
-        const isSearch = facts.inputs > 0 && facts.hasSearchAddon;
-        if (isSearch || facts.hasClearButton || isFixedAdornments(node)) {
-          context.report({ node: node.openingElement, messageId: "hand-built-field" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/jsx-class-utility.js

@@ -1,200 +0,0 @@
-/*
- * The className reader of no-shadcn-appearance-override.
- *
- * It reads LITERALS: string literals and template quasis anywhere inside a
- * `className` expression. On top
- * of that it takes EXACTLY ONE HOP: an identifier resolves to a same-file
- * `const` string literal, and an identifier or a `TABLE.key` lookup resolves to
- * a same-file `const` object whose string values are then read as classes. A
- * `{...props}` spread resolves the same way and contributes that object's
- * `className` value alone.
- *
- * One hop, and no further: nothing chains through a second binding, nothing
- * crosses a file, nothing evaluates a condition or a template, and no value the
- * hop cannot see is guessed at. That is the minimum that holds the package
- * repaint ban (`packages/design-system/DESIGN.md`, "Components") against the way
- * this repository actually authors classes — a tone table beside its component
- * and a lookup at the call site, as `VALUE_TONE_CLASS` is in
- * `packages/ui/src/components/kpi-card.tsx`. Without the
- * hop, `<Card className={tones.warning} />` repaints a primitive and no rule
- * sees it; with it, the table's own values are read.
- *
- * Standard tool checked first: `eslint-plugin-better-tailwindcss`
- * reads lookup tables through a `variable` selector with an `objectValues`
- * matcher, and the root config uses exactly that so a table's classes are
- * checked for existence. What it cannot do is say WHERE a value lands: its
- * rules judge a class on its own, never against the JSX element it is applied
- * to. "Not on an imported primitive" is a relationship between a class and an
- * element, so it stays here.
- *
- * Anything past one hop remains out of reach by design and is a review finding,
- * not a lint finding.
- */
-
-/** The same-file binding an identifier refers to, or undefined. */
-function findVariable(scope, name) {
-  for (let current = scope; current; current = current.upper) {
-    const variable = current.set.get(name);
-    if (variable) return variable;
-  }
-  return undefined;
-}
-
-/**
- * The initializer of the same-file `const` an identifier names. Undefined for
- * imports, parameters, `let`/`var`, and anything declared more than once —
- * every shape whose value is not fixed by this file alone.
- */
-function constInitializer(identifier, context) {
-  if (!context?.sourceCode) return undefined;
-  const variable = findVariable(context.sourceCode.getScope(identifier), identifier.name);
-  if (!variable || variable.defs.length !== 1) return undefined;
-  const [definition] = variable.defs;
-  if (definition.type !== "Variable" || definition.parent?.kind !== "const") return undefined;
-  return definition.node.init ?? undefined;
-}
-
-/** Every string-literal value of an object literal; a lookup can select any of them. */
-function objectStringValues(objectExpression) {
-  const values = [];
-  for (const property of objectExpression.properties) {
-    if (property.type !== "Property") continue;
-    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- ESTree types Literal.value as string | number | boolean | RegExp | bigint | null; only typeof picks the string.
-    if (property.value.type === "Literal" && typeof property.value.value === "string") {
-      values.push(property.value.value);
-    }
-  }
-  return values;
-}
-
-/** The one hop: the class strings a resolved `const` contributes, if any. */
-function resolvedFragments(identifier, context, { objectsOnly = false } = {}) {
-  const initializer = constInitializer(identifier, context);
-  if (!initializer) return [];
-  if (initializer.type === "ObjectExpression") return objectStringValues(initializer);
-  if (objectsOnly) return [];
-  const fragments = [];
-  // Read the local composition, but do not resolve another binding from it.
-  literalFragments(initializer, fragments, { skipPropertyKeys: false, context: undefined });
-  return fragments;
-}
-
-/** Every string literal and template chunk in the subtree, in source order. */
-function literalFragments(node, fragments, { skipPropertyKeys, context }) {
-  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- walks the generic AST, where only an object whose type is a string is a node.
-  if (!node || typeof node.type !== "string") return;
-
-  if (node.type === "Literal") {
-    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- ESTree types Literal.value as string | number | boolean | RegExp | bigint | null; only typeof picks the string.
-    if (typeof node.value === "string") fragments.push(node.value);
-    return;
-  }
-  if (node.type === "TemplateElement") {
-    fragments.push(node.value.cooked ?? node.value.raw);
-    return;
-  }
-  if (
-    node.type === "CallExpression" &&
-    node.callee.type === "MemberExpression" &&
-    !node.callee.computed &&
-    (node.callee.property.name === "join" ||
-      (node.callee.property.name === "filter" &&
-        node.arguments.length === 1 &&
-        node.arguments[0].type === "Identifier" &&
-        node.arguments[0].name === "Boolean"))
-  ) {
-    literalFragments(node.callee.object, fragments, { skipPropertyKeys, context });
-    return;
-  }
-  // `VALUE_TONE_CLASS[tone]` selects a class string, it does
-  // not contain one: the names inside the lookup are keys. The hop reads the
-  // table instead — any of its values can be the one selected — and the
-  // property is never descended into.
-  if (node.type === "MemberExpression") {
-    if (node.object.type === "Identifier") {
-      fragments.push(...resolvedFragments(node.object, context, { objectsOnly: true }));
-    }
-    return;
-  }
-  if (node.type === "Identifier") {
-    fragments.push(...resolvedFragments(node, context));
-    return;
-  }
-
-  for (const [key, value] of Object.entries(node)) {
-    if (key === "parent" || key === "loc" || key === "range") continue;
-    // A cva variant map's keys name variants, not classes.
-    if (skipPropertyKeys && key === "key" && node.type === "Property" && !node.computed) continue;
-    if (Array.isArray(value)) {
-      for (const child of value) literalFragments(child, fragments, { skipPropertyKeys, context });
-      // oxlint-disable-next-line anti-slop/no-runtime-typeof -- walks the generic AST, where only an object whose type is a string is a node.
-    } else if (value && typeof value === "object") {
-      literalFragments(value, fragments, { skipPropertyKeys, context });
-    }
-  }
-}
-
-function utilities(node, { skipPropertyKeys = false, context } = {}) {
-  const fragments = [];
-  literalFragments(node, fragments, { skipPropertyKeys, context });
-  return fragments.flatMap((fragment) => fragment.split(/\s+/).filter(Boolean));
-}
-
-/**
- * The class utilities written in one `className` JSX attribute. Pass `context`
- * to take the one hop; without it the reader stays literal-only.
- */
-export function classUtilities(attribute, context, includeSlots = false) {
-  if (attribute?.type !== "JSXAttribute" || !isClassProperty(attribute.name.name, includeSlots))
-    return [];
-  return utilities(attribute.value, { context });
-}
-
-function isClassProperty(name, includeSlots) {
-  return name === "className" || (includeSlots && /ClassName$/.test(name));
-}
-
-/** The `className` a spread object carries — its own key only, not its other values. */
-function spreadClassUtilities(attribute, context, includeSlots) {
-  if (attribute.argument.type !== "Identifier") return [];
-  const initializer = constInitializer(attribute.argument, context);
-  if (initializer?.type !== "ObjectExpression") return [];
-  const values = [];
-  for (const property of initializer.properties) {
-    if (property.type !== "Property" || property.computed) continue;
-    const name = property.key.type === "Identifier" ? property.key.name : property.key.value;
-    if (!isClassProperty(name, includeSlots) && name !== "class") continue;
-    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- ESTree types Literal.value as string | number | boolean | RegExp | bigint | null; only typeof picks the string.
-    if (property.value.type !== "Literal" || typeof property.value.value !== "string") continue;
-    values.push(...property.value.value.split(/\s+/).filter(Boolean));
-  }
-  return values;
-}
-
-/** The class utilities written across every attribute of one element, spreads included. */
-export function openingElementClassUtilities(node, context, includeSlots = false) {
-  return node.attributes.flatMap((attribute) =>
-    attribute.type === "JSXSpreadAttribute"
-      ? spreadClassUtilities(attribute, context, includeSlots)
-      : classUtilities(attribute, context, includeSlots),
-  );
-}
-
-/*
- * Package ownership as a per-rule option (#821, #822). `@nadicodeai/ui`'s own
- * source is the place the primitives are BUILT, so a rule that polices what
- * callers do to a primitive has nothing to say there — that is the "exempt"
- * default. A rule whose invariant holds inside the package too selects "lint".
- */
-const PACKAGE_PRIMITIVE_PATH = "packages/ui/src/";
-
-export const packageOwnedPrimitivesSchema = {
-  type: "object",
-  properties: { packageOwnedPrimitives: { enum: ["exempt", "lint"] } },
-  additionalProperties: false,
-};
-
-export function skipsPackageOwnedPrimitive(context) {
-  if (context.options?.[0]?.packageOwnedPrimitives === "lint") return false;
-  return context.filename.replaceAll("\\", "/").includes(PACKAGE_PRIMITIVE_PATH);
-}