@nadicodeai/ui 12.1.165 → 12.1.167

package/dist/eslint/index.js

@@ -1,224 +0,0 @@
-import { createHash } from "node:crypto";
-import { readdirSync, readFileSync } from "node:fs";
-
-import { builtinRules } from "eslint/use-at-your-own-risk";
-
-import { badgeIsStaticLabel } from "./rules/badge-is-static-label.js";
-import { buttonIconSlot } from "./rules/button-icon-slot.js";
-import { buttonLinkForNavigation } from "./rules/button-link-for-navigation.js";
-import { buttonNoAriaLabelWithText } from "./rules/button-no-aria-label-with-text.js";
-import { buttonTypeRolesOnlyInButtons } from "./rules/button-type-roles-only-in-buttons.js";
-import { choiceControlHasAName } from "./rules/choice-control-has-a-name.js";
-import { choiceGroupInFieldset } from "./rules/choice-group-in-fieldset.js";
-import { commandShortcutSingleOwner } from "./rules/command-shortcut-single-owner.js";
-import { confirmDialogWords } from "./rules/confirm-dialog-words.js";
-import { dataTableOneUnsizedColumn } from "./rules/data-table-one-unsized-column.js";
-import { destructiveActionPlacement } from "./rules/destructive-action-placement.js";
-import { disabledChoiceSaysWhy } from "./rules/disabled-choice-says-why.js";
-import { disabledControlAppearance } from "./rules/disabled-control-appearance.js";
-import { settingsLimitInFooter } from "./rules/settings-limit-in-footer.js";
-import { ellipsisOpensADialog } from "./rules/ellipsis-opens-a-dialog.js";
-import { emptyStateOwner } from "./rules/empty-state-owner.js";
-import { inputGroupOwners } from "./rules/input-group-owners.js";
-import { kbdChildrenNoModifierText } from "./rules/kbd-children-no-modifier-text.js";
-import { menuOwner } from "./rules/menu-owner.js";
-import { middleTruncatePlacement } from "./rules/middle-truncate-placement.js";
-import { noAppFeatureComponent } from "./rules/no-app-feature-component.js";
-import { noBareButtonLabel } from "./rules/no-bare-button-label.js";
-import { noChoiceControlWrapper } from "./rules/no-choice-control-wrapper.js";
-import { noComment } from "./rules/no-comment.js";
-import { noControlInReadOnlySurface } from "./rules/no-control-in-read-only-surface.js";
-import { noDecorativeIcon } from "./rules/no-decorative-icon.js";
-import { noDeprecatedZodApi } from "./rules/no-deprecated-zod-api.js";
-import { noGlobalPatch } from "./rules/no-global-patch.js";
-import { noHandBuiltBusy } from "./rules/no-hand-built-busy.js";
-import { noHandBuiltThemePicker } from "./rules/no-hand-built-theme-picker.js";
-import { noHandBuiltTile } from "./rules/no-hand-built-tile.js";
-import { noHandFormattedDate } from "./rules/no-hand-formatted-date.js";
-import { noHandStackedAvatars } from "./rules/no-hand-stacked-avatars.js";
-import { noNestedCollapse } from "./rules/no-nested-collapse.js";
-import { noPackageComponentRedefinition } from "./rules/no-package-component-redefinition.js";
-import { noSearchInForm } from "./rules/no-search-in-form.js";
-import { noShadcnAppearanceOverride } from "./rules/no-shadcn-appearance-override.js";
-import { noShellPromptInSnippet } from "./rules/no-shell-prompt-in-snippet.js";
-import { noStockErrorWords } from "./rules/no-stock-error-words.js";
-import { noSubjectDerivedExpectation } from "./rules/no-subject-derived-expectation.js";
-import { noTooltipAroundLabelledField } from "./rules/no-tooltip-around-labelled-field.js";
-import { noWeightClassOnStrongInTypeRole } from "./rules/no-weight-class-on-strong-in-type-role.js";
-import { noWriteInSubscription } from "./rules/no-write-in-subscription.js";
-import { oneSubmenuLevel } from "./rules/one-submenu-level.js";
-import { oneToastPerFlow } from "./rules/one-toast-per-flow.js";
-import { optionCount } from "./rules/option-count.js";
-import { pageCommandLinkNotRender } from "./rules/page-command-link-not-render.js";
-import { pageComposition } from "./rules/page-composition.js";
-import { progressNeedsName } from "./rules/progress-needs-name.js";
-import { serverActionDiscipline } from "./rules/server-action-discipline.js";
-import { skeletonInRegion } from "./rules/skeleton-in-region.js";
-import { sortableHeadingUsesSort } from "./rules/sortable-heading-uses-sort.js";
-import { tableCellInsetOwner } from "./rules/table-cell-inset-owner.js";
-import { tabsSelectionIsControlled } from "./rules/tabs-selection-is-controlled.js";
-import { testFilesFromOneDefinition } from "./rules/test-files-from-one-definition.js";
-import { tooltipOnlyArrow } from "./rules/tooltip-only-arrow.js";
-import { tooltipTriggerAccessibleName } from "./rules/tooltip-trigger-accessible-name.js";
-import { workspaceDeclaresImports } from "./rules/workspace-declares-imports.js";
-import { strictDesignSystemSelectors } from "./strict-design-system.js";
-
-/**
- * The plugin carries no version of its own.
- * The published copy of this file sits at `<ui>/dist/eslint/index.js` and the
- * source sits at `tools/lint/eslint/index.js`, which puts the
- * manifest at one of two places relative to here; the `name` field says which
- * candidate is the right one, so an unrelated manifest cannot answer by accident.
- */
-const PUBLISHING_PACKAGE = "@nadicodeai/ui";
-const MANIFEST_CANDIDATES = ["../../package.json", "../../../packages/ui/package.json"];
-
-const version = readPublishedVersion();
-
-function readPublishedVersion() {
-  for (const candidate of MANIFEST_CANDIDATES) {
-    let manifest;
-    try {
-      manifest = JSON.parse(readFileSync(new URL(candidate, import.meta.url), "utf8"));
-    } catch {
-      continue;
-    }
-    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- parses package.json at its boundary; this package has no schema library.
-    if (manifest?.name === PUBLISHING_PACKAGE && typeof manifest.version === "string") {
-      return manifest.version;
-    }
-  }
-  throw new Error(
-    `@nadicodeai/eslint-plugin: no ${PUBLISHING_PACKAGE} manifest at ${MANIFEST_CANDIDATES.join(" or ")}, so the plugin cannot report the version it ships under.`,
-  );
-}
-
-/**
- * A digest of the plugin's own source. ESLint keys its lint cache on the resolved
- * config, and a plugin enters that key only by name and version, which move on a
- * release rather than on a rule edit. Configs carry this digest in `settings`, so
- * a changed rule invalidates every cached result that ran under the old one.
- */
-export const rulesDigest = digestOf([
-  "index.js",
-  "strict-design-system.js",
-  ...readdirSync(new URL("./rules/", import.meta.url))
-    .filter((name) => name.endsWith(".js") && !name.endsWith(".test.js"))
-    .sort()
-    .map((name) => `rules/${name}`),
-]);
-
-function digestOf(paths) {
-  const hash = createHash("sha256");
-  for (const path of paths) {
-    hash
-      .update(path)
-      .update("\0")
-      .update(readFileSync(new URL(`./${path}`, import.meta.url)));
-  }
-  return hash.digest("hex").slice(0, 16);
-}
-
-/*
- * The strict design-system checks that a selector expresses are core
- * `no-restricted-syntax`, registered here once per check under the check's own
- * name, with the check's selectors as the rule's default options. A config that
- * turns on one `nadicodeai/<check>` alone therefore runs that check, and
- * `flat/strict` is self-contained for a consumer of `@nadicodeai/ui/eslint`.
- */
-const restrictedSyntax = builtinRules.get("no-restricted-syntax");
-const strictSelectorRules = Object.fromEntries(
-  Object.entries(strictDesignSystemSelectors).map(([name, entries]) => [
-    name,
-    { ...restrictedSyntax, meta: { ...restrictedSyntax.meta, defaultOptions: entries } },
-  ]),
-);
-
-export const strictDesignSystemRules = {
-  ...Object.fromEntries(
-    Object.keys(strictDesignSystemSelectors).map((name) => [`nadicodeai/${name}`, "error"]),
-  ),
-  "nadicodeai/no-shadcn-appearance-override": "error",
-};
-
-/** @type {import('eslint').ESLint.Plugin} */
-const plugin = {
-  meta: {
-    name: "@nadicodeai/eslint-plugin",
-    version,
-  },
-  configs: {},
-  rules: {
-    ...strictSelectorRules,
-    "badge-is-static-label": badgeIsStaticLabel,
-    "button-icon-slot": buttonIconSlot,
-    "button-link-for-navigation": buttonLinkForNavigation,
-    "button-no-aria-label-with-text": buttonNoAriaLabelWithText,
-    "button-type-roles-only-in-buttons": buttonTypeRolesOnlyInButtons,
-    "choice-control-has-a-name": choiceControlHasAName,
-    "choice-group-in-fieldset": choiceGroupInFieldset,
-    "command-shortcut-single-owner": commandShortcutSingleOwner,
-    "confirm-dialog-words": confirmDialogWords,
-    "data-table-one-unsized-column": dataTableOneUnsizedColumn,
-    "destructive-action-placement": destructiveActionPlacement,
-    "disabled-choice-says-why": disabledChoiceSaysWhy,
-    "disabled-control-appearance": disabledControlAppearance,
-    "settings-limit-in-footer": settingsLimitInFooter,
-    "ellipsis-opens-a-dialog": ellipsisOpensADialog,
-    "empty-state-owner": emptyStateOwner,
-    "input-group-owners": inputGroupOwners,
-    "kbd-children-no-modifier-text": kbdChildrenNoModifierText,
-    "menu-owner": menuOwner,
-    "middle-truncate-placement": middleTruncatePlacement,
-    "no-app-feature-component": noAppFeatureComponent,
-    "no-bare-button-label": noBareButtonLabel,
-    "no-choice-control-wrapper": noChoiceControlWrapper,
-    "no-comment": noComment,
-    "no-control-in-read-only-surface": noControlInReadOnlySurface,
-    "no-decorative-icon": noDecorativeIcon,
-    "no-deprecated-zod-api": noDeprecatedZodApi,
-    "no-global-patch": noGlobalPatch,
-    "no-hand-built-busy": noHandBuiltBusy,
-    "no-hand-built-theme-picker": noHandBuiltThemePicker,
-    "no-hand-built-tile": noHandBuiltTile,
-    "no-hand-formatted-date": noHandFormattedDate,
-    "no-hand-stacked-avatars": noHandStackedAvatars,
-    "no-nested-collapse": noNestedCollapse,
-    "no-package-component-redefinition": noPackageComponentRedefinition,
-    "no-search-in-form": noSearchInForm,
-    "no-shadcn-appearance-override": noShadcnAppearanceOverride,
-    "no-shell-prompt-in-snippet": noShellPromptInSnippet,
-    "no-stock-error-words": noStockErrorWords,
-    "no-subject-derived-expectation": noSubjectDerivedExpectation,
-    "no-tooltip-around-labelled-field": noTooltipAroundLabelledField,
-    "no-weight-class-on-strong-in-type-role": noWeightClassOnStrongInTypeRole,
-    "no-write-in-subscription": noWriteInSubscription,
-    "one-submenu-level": oneSubmenuLevel,
-    "one-toast-per-flow": oneToastPerFlow,
-    "option-count": optionCount,
-    "page-command-link-not-render": pageCommandLinkNotRender,
-    "page-composition": pageComposition,
-    "progress-needs-name": progressNeedsName,
-    "server-action-discipline": serverActionDiscipline,
-    "skeleton-in-region": skeletonInRegion,
-    "sortable-heading-uses-sort": sortableHeadingUsesSort,
-    "table-cell-inset-owner": tableCellInsetOwner,
-    "tabs-selection-is-controlled": tabsSelectionIsControlled,
-    "test-files-from-one-definition": testFilesFromOneDefinition,
-    "tooltip-only-arrow": tooltipOnlyArrow,
-    "tooltip-trigger-accessible-name": tooltipTriggerAccessibleName,
-    "workspace-declares-imports": workspaceDeclaresImports,
-  },
-};
-
-export const strictDesignSystemConfig = [
-  {
-    name: "nadicodeai/design-system-strict",
-    plugins: { nadicodeai: plugin },
-    rules: strictDesignSystemRules,
-  },
-];
-
-plugin.configs["flat/strict"] = strictDesignSystemConfig;
-
-export default plugin;

package/dist/eslint/rules/badge-is-static-label.js

@@ -1,93 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector such as
- * `Badge Badge` matches a name written in the file, not the element bound to
- * the package's Badge, so it misses a renamed import and flags a product's own
- * `Badge`; and `Badge[icon]` cannot tell a label inside the `icon` prop from
- * an icon. This rule joins each element to its import first.
- */
-import { partOf, renderedImports, staticAttribute } from "./rendered-import.js";
-
-const exportedBy = (module) => [
-  { from: `@nadicodeai/ui/components/${module}`, part: module },
-  { from: "@nadicodeai/ui", part: module },
-  { from: `@/components/${module}`, part: module },
-];
-
-const PARTS = new Map([
-  ["Badge", exportedBy("badge")],
-  [
-    "StatusBadge",
-    [
-      ...exportedBy("status-badge"),
-      { from: "@/components/kit/status-badge", part: "status-badge" },
-    ],
-  ],
-  ["Tag", exportedBy("tag")],
-  ["TrendBadge", exportedBy("trend-badge")],
-]);
-
-const HOSTS = new Set(["badge", "status-badge"]);
-const BUTTON_ATTRIBUTES = new Set(["tabIndex", "aria-pressed", "onKeyDown", "onKeyUp"]);
-
-const attributeName = (attribute) =>
-  attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier"
-    ? attribute.name.name
-    : null;
-
-export const badgeIsStaticLabel = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A Badge or StatusBadge is a static label: no label inside it, no button behaviour on it.",
-    },
-    schema: [],
-    messages: {
-      "static-label":
-        'A badge is a static label of text, or one icon and text. Put a second label beside it; a value that can be acted on is a Button, or a link with <Badge render={<a href=... />} variant="pill">.',
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const partOfElement = (element) =>
-      partOf(importOf(element.openingElement.name), PARTS, context.filename);
-    const isHost = (opening) => HOSTS.has(partOf(importOf(opening.name), PARTS, context.filename));
-
-    function holdingHost(label) {
-      let child = label;
-      for (let current = label.parent; current; child = current, current = current.parent) {
-        const holdsAsChild =
-          current.type === "JSXElement" &&
-          current.children.includes(child) &&
-          isHost(current.openingElement);
-        if (holdsAsChild) return current;
-        if (
-          current.type === "JSXAttribute" &&
-          attributeName(current) === "icon" &&
-          isHost(current.parent)
-        ) {
-          return current.parent;
-        }
-      }
-      return null;
-    }
-
-    return {
-      JSXElement(node) {
-        if (partOfElement(node) && holdingHost(node)) {
-          context.report({ node, messageId: "static-label" });
-        }
-      },
-      JSXOpeningElement(node) {
-        if (!isHost(node)) return;
-        for (const attribute of node.attributes) {
-          const name = attributeName(attribute);
-          const refused =
-            BUTTON_ATTRIBUTES.has(name) ||
-            (name === "role" && staticAttribute(node, "role") === "button");
-          if (refused) context.report({ node: attribute, messageId: "static-label" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/button-icon-slot.js

@@ -1,102 +0,0 @@
-/*
- * Standard tool checked first: the `repo/shadcn-composition` selector in the
- * root config (`Button JSXOpeningElement[name.name=/Icon$/]` without
- * `data-icon`) matches by element name under any `Button`, so it cannot tell a
- * text Button from an icon-only one (the size decides where an icon goes), nor
- * a `Button` imported from `@nadicodeai/ui` from a local one, nor an icon bound
- * to an icon module from a component that only ends in `Icon`.
- */
-import {
-  PACKAGE_BARREL,
-  partOf,
-  renderedImports,
-  sourceMatches,
-  staticAttribute,
-  writtenName,
-} from "./rendered-import.js";
-
-const BUTTONS = new Map(
-  ["Button", "ButtonLink"].map((name) => [
-    name,
-    ["@nadicodeai/ui/components/button", PACKAGE_BARREL].map((from) => ({ from, part: name })),
-  ]),
-);
-
-const TEXT_SIZES = new Set(["default", "xs", "sm", "lg"]);
-
-const isAttribute = (attribute, name) =>
-  attribute.type === "JSXAttribute" && attribute.name.name === name;
-
-export const buttonIconSlot = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A text Button takes its icon as prefix or suffix; an icon-only Button takes the icon as its child with no data-icon.",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          iconModules: { type: "array", items: { type: "string" }, uniqueItems: true },
-        },
-        additionalProperties: false,
-      },
-    ],
-    defaultOptions: [{ iconModules: ["lucide-react", "@nadicodeai/ui/components/house-icons"] }],
-    messages: {
-      "icon-slot":
-        'Pass an icon in a text Button as prefix={<Icon />} or suffix={<Icon />}; an icon-only Button (size="icon") takes the icon as its child.',
-    },
-  },
-  create(context) {
-    const [{ iconModules }] = context.options;
-    const importOf = renderedImports(context);
-    const isButton = (openingElement) =>
-      partOf(importOf(openingElement.name), BUTTONS, context.filename) !== null;
-
-    const isIcon = (openingElement) => {
-      const imported = importOf(openingElement.name);
-      if (
-        imported &&
-        iconModules.some((module) => sourceMatches(imported.source, module, context.filename))
-      ) {
-        return true;
-      }
-      return /Icon$/.test(writtenName(openingElement.name) ?? "");
-    };
-
-    function enclosingButton(node) {
-      for (let current = node.parent.parent; current; current = current.parent) {
-        if (current.type === "JSXAttribute") return null;
-        if (current.type === "JSXElement" && isButton(current.openingElement)) {
-          return current.openingElement;
-        }
-      }
-      return null;
-    }
-
-    function takesTextSize(button) {
-      if (button.attributes.some((attribute) => attribute.type === "JSXSpreadAttribute")) {
-        return false;
-      }
-      if (!button.attributes.some((attribute) => isAttribute(attribute, "size"))) return true;
-      return TEXT_SIZES.has(staticAttribute(button, "size"));
-    }
-
-    return {
-      JSXOpeningElement(node) {
-        if (node.parent.type !== "JSXElement") return;
-        const carriesDataIcon = node.attributes.some((attribute) =>
-          isAttribute(attribute, "data-icon"),
-        );
-        if (!carriesDataIcon && !isIcon(node)) return;
-        const button = enclosingButton(node);
-        if (!button) return;
-        if (carriesDataIcon || takesTextSize(button)) {
-          context.report({ node, messageId: "icon-slot" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/button-link-for-navigation.js

@@ -1,146 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-imports` can hold `buttonVariants`
- * back, but not tell the Buzz tree's own `buttonVariants` from the package's, and
- * a `no-restricted-syntax` selector cannot follow a renamed `Button` import to
- * the `onClick` and `render` it reads.
- */
-import { PACKAGE_BARREL, partOf, renderedImports, writtenName } from "./rendered-import.js";
-
-const BUTTON_MODULES = ["@nadicodeai/ui/components/button", PACKAGE_BARREL];
-
-const BUTTON = new Map([["Button", BUTTON_MODULES.map((from) => ({ from, part: "Button" }))]]);
-
-const LINK_ELEMENTS = new Set(["a", "Link", "NextLink"]);
-const ROUTER_METHODS = new Set(["push", "replace"]);
-const FUNCTIONS = new Set(["FunctionExpression", "ArrowFunctionExpression"]);
-
-function variantsBindings(context) {
-  const names = new Set();
-  const namespaces = new Set();
-  for (const statement of context.sourceCode.ast.body) {
-    if (statement.type !== "ImportDeclaration" || statement.importKind === "type") continue;
-    if (!BUTTON_MODULES.includes(statement.source.value)) continue;
-    for (const specifier of statement.specifiers) {
-      if (specifier.importKind === "type") continue;
-      if (specifier.type === "ImportNamespaceSpecifier") namespaces.add(specifier.local.name);
-      else if (
-        specifier.type === "ImportSpecifier" &&
-        (specifier.imported.name ?? specifier.imported.value) === "buttonVariants"
-      ) {
-        names.add(specifier.local.name);
-      }
-    }
-  }
-  return (callee) => {
-    if (callee.type === "Identifier") return names.has(callee.name);
-    return (
-      callee.type === "MemberExpression" &&
-      !callee.computed &&
-      callee.object.type === "Identifier" &&
-      namespaces.has(callee.object.name) &&
-      callee.property.name === "buttonVariants"
-    );
-  };
-}
-
-const unwrap = (node) => {
-  if (node.type === "AwaitExpression") return unwrap(node.argument);
-  if (node.type === "UnaryExpression" && node.operator === "void") return unwrap(node.argument);
-  if (node.type === "ChainExpression") return unwrap(node.expression);
-  return node;
-};
-
-const isLocationTarget = (node) => {
-  if (node.type !== "MemberExpression" || node.computed) return false;
-  const { object, property } = node;
-  if (object.type === "Identifier") {
-    if (object.name === "window") return property.name === "location";
-    return object.name === "location" && property.name === "href";
-  }
-  return (
-    isLocationTarget(object) && object.property.name === "location" && property.name === "href"
-  );
-};
-
-function goesToAnAddress(expression) {
-  const node = unwrap(expression);
-  if (node.type === "AssignmentExpression") return isLocationTarget(node.left);
-  if (node.type !== "CallExpression") return false;
-  const { callee } = node;
-  if (callee.type === "Identifier") return callee.name === "navigate";
-  return (
-    callee.type === "MemberExpression" &&
-    !callee.computed &&
-    callee.object.type === "Identifier" &&
-    callee.object.name === "router" &&
-    ROUTER_METHODS.has(callee.property.name)
-  );
-}
-
-function onlyGoesToAnAddress(fn) {
-  if (fn.body.type !== "BlockStatement") return goesToAnAddress(fn.body);
-  const { body } = fn.body;
-  return (
-    body.length > 0 &&
-    body.every(
-      (statement) =>
-        statement.type === "ExpressionStatement" && goesToAnAddress(statement.expression),
-    )
-  );
-}
-
-const attributeValue = (openingElement, attributeName) => {
-  const attribute = openingElement.attributes.find(
-    (candidate) => candidate.type === "JSXAttribute" && candidate.name.name === attributeName,
-  );
-  return attribute?.value?.type === "JSXExpressionContainer" ? attribute.value.expression : null;
-};
-
-const isLinkElement = (node) =>
-  node?.type === "JSXElement" && LINK_ELEMENTS.has(writtenName(node.openingElement.name) ?? "");
-
-function enclosingAttribute(node) {
-  for (let current = node.parent; current; current = current.parent) {
-    if (current.type === "JSXAttribute") return current;
-  }
-  return null;
-}
-
-export const buttonLinkForNavigation = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "A control that goes to an address is a ButtonLink; a Button runs a command.",
-    },
-    schema: [],
-    messages: {
-      "navigating-button":
-        "A control that goes to an address is a ButtonLink; a Button runs a command.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const isButtonVariants = variantsBindings(context);
-    return {
-      CallExpression(node) {
-        if (!isButtonVariants(node.callee)) return;
-        const attribute = enclosingAttribute(node);
-        if (attribute?.name.name !== "className") return;
-        if (isLinkElement(attribute.parent.parent)) {
-          context.report({ node, messageId: "navigating-button" });
-        }
-      },
-      JSXOpeningElement(node) {
-        if (partOf(importOf(node.name), BUTTON, context.filename) !== "Button") return;
-        const onClick = attributeValue(node, "onClick");
-        if (onClick && FUNCTIONS.has(onClick.type) && onlyGoesToAnAddress(onClick)) {
-          context.report({ node, messageId: "navigating-button" });
-          return;
-        }
-        if (isLinkElement(attributeValue(node, "render"))) {
-          context.report({ node, messageId: "navigating-button" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/button-no-aria-label-with-text.js

@@ -1,75 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match
- * `JSXElement[openingElement.name.name='Button']:has(JSXAttribute[name.name='aria-label'])`,
- * but not that the element is the package's Button rather than a local one with
- * the same name, nor that a child is text rather than an icon, nor the `size`
- * that makes a non-literal child an icon-only label. Those need the import
- * binding and the children read together.
- */
-import { PACKAGE_BARREL, partOf, renderedImports, staticAttribute } from "./rendered-import.js";
-
-const BUTTONS = new Map(
-  ["Button", "ButtonLink"].map((name) => [
-    name,
-    ["@nadicodeai/ui/components/button", PACKAGE_BARREL].map((from) => ({ from, part: name })),
-  ]),
-);
-
-const NAMING_ATTRIBUTES = new Set(["aria-label", "aria-labelledby"]);
-
-const namesItself = (openingElement) =>
-  openingElement.attributes.some(
-    (attribute) => attribute.type === "JSXAttribute" && NAMING_ATTRIBUTES.has(attribute.name.name),
-  );
-
-const isIconSize = (openingElement) =>
-  String(staticAttribute(openingElement, "size") ?? "").startsWith("icon");
-
-function staticText(expression) {
-  if (expression.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 expression.value === "string" ? expression.value : null;
-  }
-  if (expression.type === "TemplateLiteral" && expression.expressions.length === 0) {
-    return expression.quasis[0].value.cooked;
-  }
-  return null;
-}
-
-function childText(child) {
-  if (child.type === "JSXText") return child.value.trim() === "" ? "none" : "visible";
-  if (child.type !== "JSXExpressionContainer") return "none";
-  const { expression } = child;
-  if (expression.type === "JSXEmptyExpression") return "none";
-  const text = staticText(expression);
-  if (text !== null) return text.trim() === "" ? "none" : "visible";
-  return expression.type === "Literal" ? "none" : "computed";
-}
-
-export const buttonNoAriaLabelWithText = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "A Button with visible text is named by its text, never by an aria-label.",
-    },
-    schema: [],
-    messages: {
-      "named-by-its-text":
-        "A Button with visible text is named by its text; remove aria-label. When the text alone does not name the target, use `accessibleName` on a PageCommand.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    return {
-      JSXElement(node) {
-        const { openingElement } = node;
-        if (!partOf(importOf(openingElement.name), BUTTONS, context.filename)) return;
-        if (!namesItself(openingElement)) return;
-        const kinds = node.children.map(childText);
-        const showsText =
-          kinds.includes("visible") || (kinds.includes("computed") && !isIconSize(openingElement));
-        if (showsText) context.report({ node: openingElement, messageId: "named-by-its-text" });
-      },
-    };
-  },
-};