@nadicodeai/ui 12.1.165 → 12.1.166

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);
-}

package/dist/eslint/rules/kbd-children-no-modifier-text.js

@@ -1,128 +0,0 @@
-/*
- * A shortcut hint is `<Kbd meta>K</Kbd>`: the modifier is a flag, the child is
- * one key from `KBD_KEYS`, and the component draws the person's platform. A
- * hand-written ⌘ or "Ctrl" is right on one platform and wrong on the others.
- *
- * Standard tool checked first: `no-restricted-syntax` can match a `Kbd` child
- * by text, but not whether this `Kbd` is the package's (an import binding, so a
- * renamed or local `Kbd` is judged correctly), and it would need the key list
- * spelled into a regex. The list is read from the package's own `KBD_KEYS`
- * array at lint time, so a key added there changes this rule's answer with no
- * edit here.
- */
-import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-
-import { packageModules, partOf, renderedImports } from "./rendered-import.js";
-
-const KBD_MODULE = "@nadicodeai/ui/components/kbd";
-const OWNER_FILE = "packages/ui/src/components/kbd.tsx";
-
-const KBD = new Map([["Kbd", packageModules("kbd").map((from) => ({ from, part: "Kbd" }))]]);
-
-/*
- * TypeScript is loaded when this rule first runs, not when the plugin loads:
- * the plugin ships inside `@nadicodeai/ui`, which does not depend on the
- * compiler, and a consumer who never enables this rule never asks for it.
- */
-let ts;
-function typescript() {
-  ts ??= createRequire(import.meta.url)("typescript");
-  return ts;
-}
-
-function arrayLiteralOf(ts, expression) {
-  let node = expression;
-  while (
-    node &&
-    (ts.isAsExpression(node) ||
-      ts.isSatisfiesExpression(node) ||
-      ts.isParenthesizedExpression(node))
-  ) {
-    node = node.expression;
-  }
-  return node && ts.isArrayLiteralExpression(node) ? node : null;
-}
-
-function readKeys() {
-  const ts = typescript();
-  const file = fileURLToPath(import.meta.resolve(KBD_MODULE));
-  const source = ts.createSourceFile(
-    file,
-    readFileSync(file, "utf8"),
-    ts.ScriptTarget.Latest,
-    false,
-    file.endsWith(".js") ? ts.ScriptKind.JS : ts.ScriptKind.TSX,
-  );
-  for (const statement of source.statements) {
-    if (!ts.isVariableStatement(statement)) continue;
-    for (const declaration of statement.declarationList.declarations) {
-      if (!ts.isIdentifier(declaration.name) || declaration.name.text !== "KBD_KEYS") continue;
-      const array = arrayLiteralOf(ts, declaration.initializer);
-      if (!array) break;
-      return new Set(array.elements.map((element) => element.text));
-    }
-  }
-  throw new Error(`${file} has no KBD_KEYS array literal to read the keys from.`);
-}
-
-let keys;
-
-/** Read once per lint process; the built module does not move under it. */
-function kbdKeys() {
-  keys ??= readKeys();
-  return keys;
-}
-
-function writtenText(child) {
-  if (child.type === "JSXText") return child.value.trim() === "" ? null : child.value.trim();
-  if (child.type !== "JSXExpressionContainer") return null;
-  const { expression } = child;
-  // 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 (expression.type === "Literal" && typeof expression.value === "string") {
-    return expression.value;
-  }
-  if (expression.type === "TemplateLiteral" && expression.expressions.length === 0) {
-    return expression.quasis[0].value.cooked;
-  }
-  return null;
-}
-
-export const kbdChildrenNoModifierText = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A Kbd child is one key from KBD_KEYS with the modifier as a flag, and a shortcut is never a lowercase kbd element.",
-    },
-    schema: [],
-    messages: {
-      "hand-written-key":
-        "Write the modifier as a flag, <Kbd meta>K</Kbd>, and the child as one key from KBD_KEYS. A hand-written glyph shows the wrong key on Windows and Linux.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const ownsTheElement = context.filename.replaceAll("\\", "/").endsWith(`/${OWNER_FILE}`);
-
-    return {
-      JSXElement(node) {
-        const name = node.openingElement.name;
-        if (name.type === "JSXIdentifier" && name.name === "kbd") {
-          if (!ownsTheElement) {
-            context.report({ node: node.openingElement, messageId: "hand-written-key" });
-          }
-          return;
-        }
-        if (partOf(importOf(name), KBD, context.filename) !== "Kbd") return;
-        for (const child of node.children) {
-          const text = writtenText(child);
-          if (text !== null && !kbdKeys().has(text)) {
-            context.report({ node: child, messageId: "hand-written-key" });
-          }
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/literal-text.js

@@ -1,41 +0,0 @@
-import { staticAttribute } from "./rendered-import.js";
-
-/** The string a Literal or a template without expressions states, else null. */
-export function literalText(node) {
-  if (!node) return null;
-  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.
-    return typeof node.value === "string" ? node.value : null;
-  }
-  if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
-    return node.quasis[0].value.cooked;
-  }
-  return null;
-}
-
-/** The text a JSX element's children state when all of them are literal text, else null. */
-export function childText(element) {
-  let text = "";
-  for (const child of element.children) {
-    if (child.type === "JSXText") text += child.value;
-    else if (child.type === "JSXExpressionContainer" && literalText(child.expression) !== null) {
-      text += literalText(child.expression);
-    } else return null;
-  }
-  const trimmed = text.replace(/\s+/g, " ").trim();
-  return trimmed === "" ? null : trimmed;
-}
-
-/** The key an object property names, else null. */
-export function keyName(property) {
-  if (property.type !== "Property" || property.computed) return null;
-  if (property.key.type === "Identifier") return property.key.name;
-  return literalText(property.key);
-}
-
-/** An attribute's value when the source states it as a string, else null. */
-export function stringAttribute(openingElement, name) {
-  const value = staticAttribute(openingElement, name);
-  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- staticAttribute returns true, a number or a string; only typeof picks the string.
-  return typeof value === "string" ? value : null;
-}