@nadicodeai/ui 12.1.164 → 12.1.166

package/dist/eslint/rules/button-type-roles-only-in-buttons.js

@@ -1,83 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-syntax` can match a class token
- * in a `className` literal (strict-design-system.js does), but not which file
- * the token is in, so it cannot allow the files that render a button and refuse
- * the rest, nor tell the small role's two files from the other four.
- */
-
-const BUTTON_ROLE = /(?:^|:)!?(text-button(?:-lg|-xs)?|nc-type-button(?:-[a-z0-9]+)*)!?$/;
-const SMALL_ROLE = /-xs$/;
-const CLASS_FUNCTIONS = new Set(["cva", "cn"]);
-
-const inFiles = (filename, files) => {
-  const path = filename.replaceAll("\\", "/");
-  return files.some((file) => path === file || path.endsWith(`/${file}`));
-};
-
-const classSite = (node) => {
-  for (let current = node.parent; current; current = current.parent) {
-    if (current.type === "JSXAttribute") return current.name.name === "className";
-    if (
-      current.type === "CallExpression" &&
-      current.callee.type === "Identifier" &&
-      CLASS_FUNCTIONS.has(current.callee.name)
-    ) {
-      return true;
-    }
-  }
-  return false;
-};
-
-const isVariantKey = (node) => node.parent.type === "Property" && node.parent.key === node;
-
-export const buttonTypeRolesOnlyInButtons = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "The button type roles label a component that renders a button, in the files that render one.",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          allow: { type: "array", items: { type: "string" }, uniqueItems: true },
-          allowSmall: { type: "array", items: { type: "string" }, uniqueItems: true },
-        },
-        additionalProperties: false,
-      },
-    ],
-    defaultOptions: [{ allow: [], allowSmall: [] }],
-    messages: {
-      "button-role":
-        "Button type roles label a component that renders a button. Use a body-* or label-* role for other text; text-button-xs is only for the small button inside a field.",
-    },
-  },
-  create(context) {
-    const [{ allow, allowSmall }] = context.options;
-    const inAllowed = inFiles(context.filename, allow);
-    const inSmallAllowed = inFiles(context.filename, allowSmall);
-
-    const refused = (value) =>
-      value
-        .split(/\s+/)
-        .map((utility) => BUTTON_ROLE.exec(utility)?.[1])
-        .filter(Boolean)
-        .some((role) => (SMALL_ROLE.test(role) ? !inSmallAllowed : !inAllowed));
-
-    function check(node, value) {
-      if (isVariantKey(node) || !classSite(node)) return;
-      if (refused(value)) context.report({ node, messageId: "button-role" });
-    }
-
-    return {
-      Literal(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 string.
-        if (typeof node.value === "string") check(node, node.value);
-      },
-      TemplateElement(node) {
-        check(node, node.value.cooked ?? node.value.raw);
-      },
-    };
-  },
-};

package/dist/eslint/rules/choice-control-has-a-name.js

@@ -1,98 +0,0 @@
-/*
- * Standard tool checked first: `jsx-a11y/label-has-associated-control` checks a
- * Label for a control, not a control for a name, and a `no-restricted-syntax`
- * selector cannot tell that the package's Checkbox is meant rather than a local
- * one, that a Label elsewhere in the file points at its id through `htmlFor`,
- * or that a labelling ancestor wraps it. Those need the import bindings, the
- * ancestors and the file's labels read together.
- */
-import { packageModules, partOf, renderedImports, staticAttribute } from "./rendered-import.js";
-
-const partsIn = (module, names) =>
-  names.map((name) => [
-    name,
-    [...packageModules(module), `@/components/${module}`].map((from) => ({ from, part: name })),
-  ]);
-
-const CONTROLS = new Map([
-  ...partsIn("checkbox", ["Checkbox"]),
-  ...partsIn("switch", ["Switch"]),
-  ...partsIn("radio-group", ["RadioGroupItem"]),
-]);
-
-const LABELS = new Map([...partsIn("label", ["Label"]), ...partsIn("field", ["FieldLabel"])]);
-
-const NAMING_ANCESTORS = new Map([...LABELS, ...partsIn("settings-section", ["SettingsField"])]);
-
-const NAMING_ATTRIBUTES = new Set(["aria-label", "aria-labelledby"]);
-
-const findAttribute = (openingElement, name) =>
-  openingElement.attributes.find(
-    (attribute) => attribute.type === "JSXAttribute" && attribute.name.name === name,
-  );
-
-const hasSpread = (openingElement) =>
-  openingElement.attributes.some((attribute) => attribute.type === "JSXSpreadAttribute");
-
-export const choiceControlHasAName = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A Checkbox, Switch or RadioGroupItem is named by an aria-label, an aria-labelledby, a Label with htmlFor, or a labelling ancestor.",
-    },
-    schema: [],
-    messages: {
-      unnamed:
-        "Name this control: give it an aria-label (a row's checkbox: Select <row name>), an aria-labelledby, or a Label with htmlFor.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const isPart = (parts) => (openingElement) =>
-      Boolean(partOf(importOf(openingElement.name), parts, context.filename));
-    const isControl = isPart(CONTROLS);
-    const isLabel = isPart(LABELS);
-    const isNamingAncestor = isPart(NAMING_ANCESTORS);
-
-    const reference = (openingElement, attributeName) => {
-      const attribute = findAttribute(openingElement, attributeName);
-      if (!attribute) return null;
-      const stated = staticAttribute(openingElement, attributeName);
-      if (stated !== undefined) return String(stated);
-      return attribute.value ? context.sourceCode.getText(attribute.value) : null;
-    };
-
-    const controls = [];
-    const pointedAt = new Set();
-
-    const hasNamingAncestor = (element) => {
-      for (let current = element.parent; current; current = current.parent) {
-        if (current.type === "JSXElement" && isNamingAncestor(current.openingElement)) return true;
-      }
-      return false;
-    };
-
-    return {
-      JSXElement(node) {
-        const { openingElement } = node;
-        if (isLabel(openingElement)) {
-          const target = reference(openingElement, "htmlFor");
-          if (target !== null) pointedAt.add(target);
-          return;
-        }
-        if (!isControl(openingElement)) return;
-        if (hasSpread(openingElement)) return;
-        if (openingElement.attributes.some((a) => NAMING_ATTRIBUTES.has(a.name?.name))) return;
-        if (hasNamingAncestor(node)) return;
-        controls.push({ node: openingElement, id: reference(openingElement, "id") });
-      },
-      "Program:exit"() {
-        for (const { node, id } of controls) {
-          if (id !== null && pointedAt.has(id)) continue;
-          context.report({ node, messageId: "unnamed" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/choice-group-in-fieldset.js

@@ -1,86 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match a
- * `RadioGroup` without a `FieldSet` ancestor, but not that the `FieldSet`
- * holds a `FieldLegend`, nor that two `Checkbox` elements share a parent once
- * each sits in its own `Field`, so it would miss the checkbox group.
- */
-import { findBelow, renderedImports } from "./rendered-import.js";
-
-const FROM_DESIGN_SYSTEM = /^(@nadicodeai\/ui(\/|$)|@\/|\.)/;
-const ROW_WRAPPERS = new Set(["Field", "FieldContent", "FieldLabel", "Label"]);
-
-const isRepeater = (node) =>
-  (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") &&
-  node.parent.type === "CallExpression" &&
-  node.parent.callee.type === "MemberExpression" &&
-  node.parent.callee.property.name === "map";
-
-export const choiceGroupInFieldset = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "A group of radios or checkboxes sits in a FieldSet with a FieldLegend.",
-    },
-    schema: [],
-    messages: {
-      "choice-group":
-        "A group of radios or checkboxes sits in a FieldSet with a FieldLegend, so the group is announced by its legend.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const exportOf = (element) => {
-      const imported = importOf(element.openingElement.name);
-      return imported && FROM_DESIGN_SYSTEM.test(imported.source) ? imported.name : null;
-    };
-    const checkboxGroups = new Map();
-
-    function hasLegendedFieldSet(node) {
-      for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
-        if (ancestor.type !== "JSXElement" || exportOf(ancestor) !== "FieldSet") continue;
-        const legend = findBelow(
-          ancestor,
-          context.sourceCode.visitorKeys,
-          (child) => child.type === "JSXElement" && exportOf(child) === "FieldLegend",
-        );
-        if (legend) return true;
-      }
-      return false;
-    }
-
-    function reportUnlessGrouped(element) {
-      if (!hasLegendedFieldSet(element)) {
-        context.report({ node: element.openingElement, messageId: "choice-group" });
-      }
-    }
-
-    function recordCheckbox(element) {
-      let repeated = false;
-      let parent = element.parent;
-      while (parent) {
-        if (isRepeater(parent)) repeated = true;
-        const isRow = parent.type === "JSXElement" && ROW_WRAPPERS.has(exportOf(parent));
-        const isGroup = (parent.type === "JSXElement" || parent.type === "JSXFragment") && !isRow;
-        if (isGroup) break;
-        parent = parent.parent;
-      }
-      if (!parent) return;
-      const group = checkboxGroups.get(parent) ?? { first: element, count: 0 };
-      group.count += repeated ? 2 : 1;
-      checkboxGroups.set(parent, group);
-    }
-
-    return {
-      JSXElement(node) {
-        const name = exportOf(node);
-        if (name === "RadioGroup") reportUnlessGrouped(node);
-        else if (name === "Checkbox") recordCheckbox(node);
-      },
-      "Program:exit"() {
-        for (const { first, count } of checkboxGroups.values()) {
-          if (count >= 2) reportUnlessGrouped(first);
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/command-shortcut-single-owner.js

@@ -1,118 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match the
- * string `"mod+k"`, but not a handler that reads `key` and `metaKey` as two
- * separate checks (`(e.metaKey || e.ctrlKey) && e.key === "k"`), because the
- * two reads only mean a shortcut together, in the same function; and it cannot
- * allow the files that own Find.
- */
-
-const SHORTCUT_STRING = /^(?:mod|meta|cmd|ctrl)\+k$/i;
-const MODIFIER_PROPERTIES = new Set(["metaKey", "ctrlKey"]);
-const CASE_METHODS = new Set(["toLowerCase", "toUpperCase"]);
-const KEY_VALUES = { key: new Set(["k", "K"]), code: new Set(["KeyK"]) };
-
-const inFiles = (filename, files) => {
-  const path = filename.replaceAll("\\", "/");
-  return files.some((file) => path === file || path.endsWith(`/${file}`));
-};
-
-const unwrapChain = (node) => (node.type === "ChainExpression" ? node.expression : node);
-
-const propertyName = (member) =>
-  member.type === "MemberExpression" && !member.computed ? member.property.name : null;
-
-function keyRead(node) {
-  const read = unwrapChain(node);
-  if (read.type === "CallExpression") {
-    const callee = unwrapChain(read.callee);
-    if (propertyName(callee) && CASE_METHODS.has(propertyName(callee))) {
-      return keyRead(callee.object);
-    }
-    return null;
-  }
-  const name = propertyName(read);
-  return name && name in KEY_VALUES ? name : null;
-}
-
-const isLetterK = (read, literal) =>
-  literal.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.
-  typeof literal.value === "string" &&
-  KEY_VALUES[read].has(literal.value);
-
-const COMPARISONS = new Set(["===", "==", "!==", "!="]);
-
-export const commandShortcutSingleOwner = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Only the files that own Find bind the command-and-K shortcut.",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          owners: { type: "array", items: { type: "string" }, uniqueItems: true },
-        },
-        additionalProperties: false,
-      },
-    ],
-    defaultOptions: [{ owners: [] }],
-    messages: {
-      "find-shortcut": "⌘K and Ctrl+K belong to Find. Bind an in-page field to another key.",
-    },
-  },
-  create(context) {
-    if (inFiles(context.filename, context.options[0].owners)) return {};
-
-    const frames = [{ letterKs: [], readsModifier: false }];
-    const frame = () => frames.at(-1);
-
-    const enter = () => frames.push({ letterKs: [], readsModifier: false });
-    const leave = () => {
-      const { letterKs, readsModifier } = frames.pop();
-      if (!readsModifier) return;
-      for (const node of letterKs) context.report({ node, messageId: "find-shortcut" });
-    };
-
-    const checkString = (node, value) => {
-      if (SHORTCUT_STRING.test(value.trim())) context.report({ node, messageId: "find-shortcut" });
-    };
-
-    const noteLetterK = (node, read, other) => {
-      const name = keyRead(read);
-      if (name && isLetterK(name, other)) frame().letterKs.push(node);
-    };
-
-    return {
-      FunctionDeclaration: enter,
-      FunctionExpression: enter,
-      ArrowFunctionExpression: enter,
-      "FunctionDeclaration:exit": leave,
-      "FunctionExpression:exit": leave,
-      "ArrowFunctionExpression:exit": leave,
-      "Program:exit"() {
-        leave();
-      },
-      MemberExpression(node) {
-        if (MODIFIER_PROPERTIES.has(propertyName(node))) frame().readsModifier = true;
-      },
-      BinaryExpression(node) {
-        if (!COMPARISONS.has(node.operator)) return;
-        noteLetterK(node, node.left, node.right);
-        noteLetterK(node, node.right, node.left);
-      },
-      SwitchCase(node) {
-        if (node.test) noteLetterK(node, node.parent.discriminant, node.test);
-      },
-      Literal(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 string.
-        if (typeof node.value === "string") checkString(node, node.value);
-      },
-      TemplateElement(node) {
-        if (node.parent.type === "TemplateLiteral" && node.parent.expressions.length === 0)
-          checkString(node, node.value.cooked ?? "");
-      },
-    };
-  },
-};

package/dist/eslint/rules/confirm-dialog-words.js

@@ -1,63 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-syntax` reads one attribute at a
- * time, and this check compares two of them on the same element (the title's
- * verb with the confirm label's), and must know the element is the package's
- * `ConfirmDialog` or the Portal's wrapper of it, not a local component.
- */
-import { stringAttribute } from "./literal-text.js";
-import { renderedImports, writtenName } from "./rendered-import.js";
-
-const DIALOGS = new Set(["ConfirmDialog", "ConfirmedActionForm"]);
-const QUESTION_OPENING = /^(?:are you sure|do you (?:really )?want|would you like|should)\b/i;
-
-const words = (text) => text.trim().split(/\s+/).filter(Boolean);
-
-export const confirmDialogWords = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A ConfirmDialog's title is a statement, and its confirm label repeats the title's verb with the noun.",
-    },
-    schema: [],
-    messages: {
-      "title-is-a-question":
-        'The title of a confirmation is a statement that names the record, "Remove pec@acme.it", never a question.',
-      "confirm-label-bare":
-        'The confirm label repeats the verb and the noun, "Remove mailbox"; "{{label}}" alone does not say what is confirmed.',
-      "confirm-verb-differs":
-        'The confirm label repeats the title\'s verb: the title says "{{title}}", so the label starts with "{{verb}}", not "{{label}}".',
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-
-    return {
-      JSXOpeningElement(node) {
-        if (!importOf(node.name) || !DIALOGS.has(writtenName(node.name))) return;
-        const titleText = stringAttribute(node, "title");
-        const labelText = stringAttribute(node, "confirmLabel");
-        if (
-          titleText !== null &&
-          (titleText.trim().endsWith("?") || QUESTION_OPENING.test(titleText.trim()))
-        ) {
-          context.report({ node, messageId: "title-is-a-question" });
-        }
-        if (labelText === null) return;
-        const labelWords = words(labelText);
-        if (labelWords.length < 2) {
-          context.report({ node, messageId: "confirm-label-bare", data: { label: labelText } });
-          return;
-        }
-        const verb = titleText === null ? undefined : words(titleText)[0];
-        if (verb !== undefined && verb.toLowerCase() !== labelWords[0].toLowerCase()) {
-          context.report({
-            node,
-            messageId: "confirm-verb-differs",
-            data: { title: titleText, verb, label: labelText },
-          });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/data-table-one-unsized-column.js

@@ -1,96 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector matches one
- * node, but this reads a whole `columns` array (how many of its objects lack a
- * `size`, whether one sets `meta.wraps`, whether a spread or a call makes the
- * list unknowable) and follows a variable to its array, which no selector can.
- */
-import { renderedImports } from "./rendered-import.js";
-
-const COMMANDS_COLUMN_ID = "actions";
-
-const WRAPPERS = new Set(["TSAsExpression", "TSSatisfiesExpression", "TSNonNullExpression"]);
-
-function unwrap(node) {
-  let current = node;
-  while (WRAPPERS.has(current.type)) current = current.expression;
-  return current;
-}
-
-const keyName = (property) => {
-  if (property.computed) return null;
-  return property.key.type === "Identifier" ? property.key.name : property.key.value;
-};
-
-const propertyOf = (column, name) =>
-  column.properties.find((property) => property.type === "Property" && keyName(property) === name);
-
-function setsWraps(column) {
-  const meta = propertyOf(column, "meta")?.value;
-  if (meta?.type !== "ObjectExpression") return false;
-  const wraps = propertyOf(meta, "wraps")?.value;
-  return wraps !== undefined && !(wraps.type === "Literal" && wraps.value === false);
-}
-
-const isCommandsColumn = (column) => propertyOf(column, "id")?.value.value === COMMANDS_COLUMN_ID;
-
-const isKnownColumn = (element) =>
-  element?.type === "ObjectExpression" &&
-  element.properties.every((property) => property.type === "Property");
-
-function arrayOf(context, expression) {
-  const node = unwrap(expression);
-  if (node.type === "ArrayExpression") return node;
-  if (node.type !== "Identifier") return null;
-  for (let scope = context.sourceCode.getScope(node); scope; scope = scope.upper) {
-    const variable = scope.set.get(node.name);
-    if (!variable) continue;
-    const [definition] = variable.defs;
-    const initialisedOnce =
-      variable.defs.length === 1 && variable.references.filter((use) => use.isWrite()).length === 1;
-    if (!initialisedOnce || definition.node.type !== "VariableDeclarator") return null;
-    const init = definition.node.init ? unwrap(definition.node.init) : null;
-    return init?.type === "ArrayExpression" ? init : null;
-  }
-  return null;
-}
-
-function breaksTheRule(array) {
-  if (!array.elements.every(isKnownColumn)) return false;
-  if (array.elements.some(setsWraps)) return false;
-  const unsized = array.elements.filter((column) => !propertyOf(column, "size"));
-  if (unsized.length > 1) return true;
-  const content = array.elements.filter((column) => !isCommandsColumn(column));
-  return content.length > 0 && unsized.length === 0;
-}
-
-export const dataTableOneUnsizedColumn = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A DataTable's columns all have a size in pixels except the one that takes the spare width.",
-    },
-    schema: [],
-    messages: {
-      "one-unsized-column":
-        "Give every column a `size` in pixels except the one that takes the spare width. Columns without a size share what is left, so two of them make the widths depend on the data.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    return {
-      JSXOpeningElement(node) {
-        if (importOf(node.name)?.name !== "DataTable") return;
-        const attribute = node.attributes.find(
-          (candidate) => candidate.type === "JSXAttribute" && candidate.name.name === "columns",
-        );
-        const value = attribute?.value;
-        if (value?.type !== "JSXExpressionContainer") return;
-        const array = arrayOf(context, value.expression);
-        if (array && breaksTheRule(array)) {
-          context.report({ node: value.expression, messageId: "one-unsized-column" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/destructive-action-placement.js

@@ -1,69 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` descendant selector can
- * match a `Button` below `SheetContent`, but not that the button is the design
- * system's, nor follow a renamed import, nor read `variant="destructive"` off
- * the opening element or ignore a match that only sits in a `render` prop.
- */
-import { renderedImports, staticAttribute } from "./rendered-import.js";
-
-const BUTTONS = new Set(["Button", "ButtonLink"]);
-const CONFIRMATIONS = new Set(["ConfirmDialog", "AlertDialog", "ConfirmActionDialog"]);
-const CLOSED_SURFACES = new Set([
-  "SheetContent",
-  "DrawerContent",
-  "FormDrawer",
-  "CatalogDrawer",
-  "AccordionContent",
-  "CollapsibleContent",
-  "Disclosure",
-  "HoverCardContent",
-]);
-
-const FROM_DESIGN_SYSTEM = /^(@nadicodeai\/ui(\/|$)|@\/|\.)/;
-
-export const destructiveActionPlacement = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A destructive action is confirmed in a ConfirmDialog opened from the page or a row's menu, never inside a sheet, drawer, hover card or collapsed section.",
-    },
-    schema: [],
-    messages: {
-      "destructive-placement":
-        "A destructive action is confirmed in a ConfirmDialog opened from the page or the row's menu: only a modal dims the whole page. Do not place it in a sheet, a drawer, a hover card or a section that starts closed.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const exportOf = (element) => {
-      const imported = importOf(element.openingElement.name);
-      return imported && FROM_DESIGN_SYSTEM.test(imported.source) ? imported.name : null;
-    };
-
-    const isDestructive = (element) => {
-      const name = exportOf(element);
-      if (CONFIRMATIONS.has(name)) return true;
-      return (
-        BUTTONS.has(name) && staticAttribute(element.openingElement, "variant") === "destructive"
-      );
-    };
-
-    function insideClosedSurface(element) {
-      let child = element;
-      for (let node = element.parent; node; child = node, node = node.parent) {
-        if (node.type !== "JSXElement" || !node.children.includes(child)) continue;
-        if (CLOSED_SURFACES.has(exportOf(node))) return true;
-      }
-      return false;
-    }
-
-    return {
-      JSXElement(node) {
-        if (isDestructive(node) && insideClosedSurface(node)) {
-          context.report({ node: node.openingElement, messageId: "destructive-placement" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/disabled-choice-says-why.js

@@ -1,71 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match a
- * `disabled` attribute on a `Checkbox`, but not follow a renamed import to the
- * component, nor read the other attributes of the same element (aria-describedby,
- * a spread) or tell a wait (`disabled={pending}`) from a reason.
- */
-import { PACKAGE_BARREL, partOf, renderedImports } from "./rendered-import.js";
-
-const MODULES = [
-  ["Checkbox", "checkbox"],
-  ["Switch", "switch"],
-  ["RadioGroupItem", "radio-group"],
-];
-
-const CHOICE = new Map(
-  MODULES.map(([part, module]) => [
-    part,
-    [`@nadicodeai/ui/components/${module}`, PACKAGE_BARREL].map((from) => ({ from, part })),
-  ]),
-);
-
-const WAIT = /^(?:is)?(?:pending|saving|submitting|busy)$/i;
-
-const unwrapChain = (node) => (node.type === "ChainExpression" ? node.expression : node);
-
-function isWait(attribute) {
-  if (attribute.value?.type !== "JSXExpressionContainer") return false;
-  const read = unwrapChain(attribute.value.expression);
-  if (read.type === "Identifier") return WAIT.test(read.name);
-  if (read.type !== "MemberExpression" || read.computed) return false;
-  return WAIT.test(read.property.name);
-}
-
-function isEnabledLiteral(attribute) {
-  const expression = attribute.value?.expression;
-  return expression?.type === "Literal" && expression.value === false;
-}
-
-const attributeNamed = (openingElement, name) =>
-  openingElement.attributes.find(
-    (attribute) => attribute.type === "JSXAttribute" && attribute.name.name === name,
-  );
-
-export const disabledChoiceSaysWhy = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A disabled Checkbox, Switch or RadioGroupItem points aria-describedby at the line that names the reason.",
-    },
-    schema: [],
-    messages: {
-      "disabled-without-reason":
-        "Say why this is disabled: point aria-describedby at the line that names the reason, or use ChoiceboxGroupItem's disabledReason.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-
-    return {
-      JSXOpeningElement(node) {
-        if (!partOf(importOf(node.name), CHOICE, context.filename)) return;
-        const disabled = attributeNamed(node, "disabled");
-        if (!disabled || isEnabledLiteral(disabled) || isWait(disabled)) return;
-        if (attributeNamed(node, "aria-describedby")) return;
-        if (node.attributes.some((attribute) => attribute.type === "JSXSpreadAttribute")) return;
-        context.report({ node: disabled, messageId: "disabled-without-reason" });
-      },
-    };
-  },
-};