@nadicodeai/ui 12.1.54 → 12.1.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nadicodeai/ui",
-  "version": "12.1.54",
+  "version": "12.1.55",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -77,7 +77,7 @@
     "@assistant-ui/react": "0.15.22",
     "@assistant-ui/react-markdown": "0.14.17",
     "@base-ui/react": "^1.8.0",
-    "@nadicodeai/design-system": "12.1.54",
+    "@nadicodeai/design-system": "12.1.55",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",

package/dist/.build-kind

@@ -1 +0,0 @@
-clean

package/dist/eslint/rules/card-row-owner.js

@@ -1,167 +0,0 @@
-/*
- * Cards that share a row share one height, and one component makes that true.
- *
- * What is read is a JSX element's OWN class utilities together with its OWN
- * direct children: the utilities say whether the element puts its children side
- * by side — a grid with more than one column, or a flex that is not a column —
- * and the children say whether those are cards. A `Card`, anything whose name
- * ends in `Card` (`OverviewChartCard`), and a `.map()` whose callback returns
- * one all count, because a mapped list is the row that goes ragged first.
- *
- * Why: a hand-written row leaves each card at its content's height, so three
- * cards with 4, 5 and 5 rows end on three different lines and a finished
- * analytics surface reads as broken (`rule/card-row-equal-height`). `CardRow`
- * from `@nadicodeai/ui` stretches its cells and makes each card fill the one it
- * lands in; a row written by hand has to remember both halves and usually
- * remembers neither.
- *
- * A vertical stack is not a row and is never reported: `flex-col`, a `grid`
- * with one column or no column count at all, and `space-y-*` each put one card
- * under the next, where equal height means nothing.
- *
- * What it cannot see, by design, because each would need another file: a card
- * behind an intermediate wrapper element, a card a child component renders from
- * its own file, and a class list the shared reader's one hop cannot resolve.
- * Those stay review findings. `packages/ui/src` is exempt by default, since that
- * is where `CardRow` and the package's own compositions are built;
- * `packageOwnedPrimitives: "lint"` holds the package to the rule too.
- *
- * Standard tool checked first: `better-tailwindcss/no-restricted-classes`
- * matches a class wherever it is written and would have to ban `grid-cols-2`
- * outright; it cannot ask what the element carrying it contains. "A multi-column
- * container whose children are cards" is a relationship between a class list and
- * a child list, so it is read here, on the shared class and component-name
- * readers.
- */
-import {
-  jsxComponentName,
-  openingElementClassUtilities,
-  packageOwnedPrimitivesSchema,
-  skipsPackageOwnedPrimitive,
-} from "./jsx-class-utility.js";
-
-const OWNER = "CardRow";
-
-function withoutVariants(token) {
-  let bracketDepth = 0;
-  let start = 0;
-  for (let index = 0; index < token.length; index += 1) {
-    if (token[index] === "[") bracketDepth += 1;
-    if (token[index] === "]") bracketDepth = Math.max(0, bracketDepth - 1);
-    if (token[index] === ":" && bracketDepth === 0) start = index + 1;
-  }
-  return token.slice(start);
-}
-
-/**
- * The utility that makes this element a row, or undefined. A `grid-cols-*` of
- * anything but one, an arbitrary column template, an explicit `flex-row`, or a
- * bare `flex` that no `flex-col` turns on its side — at any breakpoint, since a
- * row at `lg` is still a row.
- */
-function rowUtility(utilities) {
-  const unqualified = utilities.map(withoutVariants);
-  for (const utility of unqualified) {
-    if (!utility.startsWith("grid-cols-")) continue;
-    const columns = utility.slice("grid-cols-".length);
-    if (columns !== "1") return utility;
-  }
-  if (unqualified.includes("flex-row")) return "flex-row";
-  if (unqualified.includes("flex") && !unqualified.includes("flex-col")) return "flex";
-  return undefined;
-}
-
-function isCardName(name) {
-  return typeof name === "string" && (name === "Card" || /Card$/.test(name));
-}
-
-/** The element a `.map()` or `Array.from()` callback renders, descended through its return. */
-function mappedElement(expression) {
-  if (expression?.type !== "CallExpression") return undefined;
-  const { callee } = expression;
-  if (callee.type !== "MemberExpression" || callee.computed) return undefined;
-  if (callee.property.name !== "map" && callee.property.name !== "from") return undefined;
-  const callback = expression.arguments.find(
-    (argument) =>
-      argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression",
-  );
-  if (!callback) return undefined;
-  if (callback.body.type !== "BlockStatement") return returnedElement(callback.body);
-  for (const statement of callback.body.body) {
-    if (statement.type !== "ReturnStatement") continue;
-    const element = returnedElement(statement.argument);
-    if (element) return element;
-  }
-  return undefined;
-}
-
-/** The JSX element one expression renders, through parentheses and conditionals. */
-function returnedElement(node) {
-  if (!node) return undefined;
-  switch (node.type) {
-    case "JSXElement":
-      return node;
-    case "ConditionalExpression":
-      return returnedElement(node.consequent) ?? returnedElement(node.alternate);
-    case "LogicalExpression":
-      return returnedElement(node.right);
-    default:
-      return undefined;
-  }
-}
-
-/**
- * How many cards this element lays out directly. A `.map()` counts as two: one
- * expression stands for however many records there are, which is the case the
- * ragged edge shows up in. A card behind a condition counts as one.
- */
-function cardChildCount(node, context) {
-  let count = 0;
-  for (const child of node.children) {
-    if (child.type === "JSXElement") {
-      if (isCardName(jsxComponentName(child.openingElement, context))) count += 1;
-      continue;
-    }
-    if (child.type !== "JSXExpressionContainer") continue;
-    const mapped = mappedElement(child.expression);
-    if (mapped) {
-      if (isCardName(jsxComponentName(mapped.openingElement, context))) count += 2;
-      continue;
-    }
-    const conditional = returnedElement(child.expression);
-    if (conditional && isCardName(jsxComponentName(conditional.openingElement, context)))
-      count += 1;
-  }
-  return count;
-}
-
-export const cardRowOwner = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require the shared CardRow owner for a row of sibling cards",
-    },
-    schema: [packageOwnedPrimitivesSchema],
-    messages: {
-      cardRowOwner:
-        '"{{utility}}" lays these cards side by side without the owner of that row. An alignment class or a wrapper around a card is then enough for the shortest card to stop at its content and the row to end on a ragged edge. Use CardRow from @nadicodeai/ui, which stretches its cells and makes every card fill the one it lands in, wrapped in a list item or not (rule/card-row-equal-height).',
-    },
-  },
-  create(context) {
-    if (skipsPackageOwnedPrimitive(context)) return {};
-    return {
-      JSXElement(node) {
-        if (jsxComponentName(node.openingElement, context) === OWNER) return;
-        const utility = rowUtility(openingElementClassUtilities(node.openingElement, context));
-        if (!utility) return;
-        const count = cardChildCount(node, context);
-        if (count < 2) return;
-        context.report({
-          node: node.openingElement,
-          messageId: "cardRowOwner",
-          data: { utility },
-        });
-      },
-    };
-  },
-};

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

@@ -1,177 +0,0 @@
-/*
- * A destructive Server Action never fires on a bare form or submit button.
- *
- * Two shapes are destructive, and both are read off the JSX itself rather than
- * out of a registry:
- *
- * - the bound symbol follows the Portal's destructive-action naming convention
- *   (`archiveThingAction`, `removeMemberAction`, `revokeInstallationAction`);
- * - the form submits a lifecycle change to `archived`, which is how an archive
- *   is written through an otherwise ordinary update action — the hidden field
- *   is the destructive part, not the symbol's name.
- *
- * The approved carriers are `ConfirmedActionForm` and a destructive
- * `ActionDialogForm`. A component that receives a destructive action as a prop
- * binds it under that prop's name, so the convention holds at the site where
- * the binding is actually written and this rule sees it there.
- *
- * Standard tool checked first: `no-restricted-syntax` judges one
- * node at a time, and the archive shape is a relationship between two — an
- * ordinary `action={updateCustomerAction}` binding on the form, and the
- * `lifecycle_status="archived"` field somewhere below it, which is what makes
- * that ordinary binding destructive. A selector can match either node alone;
- * neither alone is a violation. Customer archival in
- * `apps/portal/src/components/customers/customer-settings-tab.tsx` is exactly that
- * shape, so the relationship has to be read, and that is what this rule does.
- *
- * Replaces the vitest guard that joined a hand-kept `CONFIRM_REQUIRED_ACTIONS`
- * ledger of file paths and symbols against a TypeScript AST walk (#821, #822).
- * What the ledger held that a derivation cannot — an action that destroys
- * nothing yet still deserves a confirmation, such as starting an impersonation,
- * and the `confirm*` callbacks behind `ConfirmDialog` — is judgment, and ADR
- * 0057 puts judgment in review rather than in machinery.
- */
-
-const DESTRUCTIVE_ACTION_NAME =
-  /^(?:archive|cancel|decline|remove|revoke|suspend|unassign)[A-Z][A-Za-z]*Action$/;
-const BINDING_ATTRIBUTES = new Set(["action", "formAction"]);
-const LIFECYCLE_FIELD = "lifecycle_status";
-const ARCHIVED = "archived";
-
-function elementName(openingElement) {
-  return openingElement?.name?.type === "JSXIdentifier" ? openingElement.name.name : undefined;
-}
-
-function openingElementOf(node) {
-  if (node.type === "JSXElement") return node.openingElement;
-  return node.type === "JSXOpeningElement" ? node : undefined;
-}
-
-function attributeValue(openingElement, name) {
-  for (const attribute of openingElement.attributes) {
-    if (attribute.type !== "JSXAttribute" || attribute.name.name !== name) continue;
-    const value = attribute.value;
-    if (value === null) return true;
-    if (value.type === "Literal") return value.value;
-    if (value.type === "JSXExpressionContainer" && value.expression.type === "Literal") {
-      return value.expression.value;
-    }
-    return undefined;
-  }
-  return undefined;
-}
-
-/** Every identifier named anywhere inside a subtree. */
-function identifiers(node, found = []) {
-  if (!node || typeof node.type !== "string") return found;
-  if (node.type === "Identifier") {
-    found.push(node.name);
-    return found;
-  }
-  for (const [key, value] of Object.entries(node)) {
-    if (key === "parent") continue;
-    if (Array.isArray(value)) {
-      for (const child of value) identifiers(child, found);
-    } else if (value && typeof value === "object") {
-      identifiers(value, found);
-    }
-  }
-  return found;
-}
-
-/*
- * The children a JSX subtree renders. A field is as often written inside a
- * `{condition && <input …/>}` or a ternary as it is written bare, so the walk
- * steps through the expression container and the two operators that carry JSX
- * inside it. Nothing is evaluated: both branches of a `&&` or a `?:` count as
- * rendered, because either one may be.
- */
-function renderedChildren(node) {
-  switch (node.type) {
-    case "JSXElement":
-    case "JSXFragment":
-      return node.children;
-    case "JSXExpressionContainer":
-      return [node.expression];
-    case "LogicalExpression":
-      return [node.left, node.right];
-    case "ConditionalExpression":
-      return [node.consequent, node.alternate];
-    default:
-      return [];
-  }
-}
-
-/** True when the subtree submits a lifecycle change to `archived`. */
-function submitsArchive(node) {
-  const opening = openingElementOf(node);
-  if (
-    opening &&
-    attributeValue(opening, "name") === LIFECYCLE_FIELD &&
-    attributeValue(opening, "value") === ARCHIVED
-  ) {
-    return true;
-  }
-  return renderedChildren(node).some((child) => submitsArchive(child));
-}
-
-function enclosingForm(node, sourceCode) {
-  const ancestors = sourceCode.getAncestors(node);
-  for (let index = ancestors.length - 1; index >= 0; index -= 1) {
-    const ancestor = ancestors[index];
-    if (ancestor.type === "JSXElement" && elementName(ancestor.openingElement) === "form") {
-      return ancestor;
-    }
-  }
-  return undefined;
-}
-
-export const confirmDestructiveAction = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Require a destructive Server Action to be bound through an approved confirmation component",
-    },
-    schema: [],
-    messages: {
-      unconfirmed:
-        "A destructive Server Action has no opt-out: bind {{binding}} through ConfirmedActionForm, a destructive ActionDialogForm, or ConfirmDialog onConfirm — never on a bare <{{tag}}>.",
-    },
-  },
-  create(context) {
-    return {
-      JSXOpeningElement(node) {
-        const tag = elementName(node);
-        if (!tag) return;
-
-        for (const attribute of node.attributes) {
-          if (attribute.type !== "JSXAttribute" || attribute.name.type !== "JSXIdentifier")
-            continue;
-          if (!BINDING_ATTRIBUTES.has(attribute.name.name)) continue;
-
-          const bound = identifiers(attribute.value).filter((name) =>
-            DESTRUCTIVE_ACTION_NAME.test(name),
-          );
-          const scope =
-            attribute.name.name === "formAction"
-              ? enclosingForm(node, context.sourceCode)
-              : node.parent;
-          const destructive = bound.length > 0 || (scope ? submitsArchive(scope) : false);
-          if (!destructive) continue;
-
-          const approved =
-            tag === "ConfirmedActionForm" ||
-            (tag === "ActionDialogForm" && attributeValue(node, "destructive") !== undefined);
-          if (approved) continue;
-
-          context.report({
-            node: attribute,
-            messageId: "unconfirmed",
-            data: { binding: bound[0] ?? `the ${ARCHIVED} lifecycle change`, tag },
-          });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/drawer-owns-its-edges.js

@@ -1,66 +0,0 @@
-/*
- * Standard tool checked first: `better-tailwindcss/no-restricted-classes` bans a
- * class everywhere and cannot ask which element it sits on or what that element
- * wraps, so the relationship is read here on the shared readers.
- */
-import { jsxComponentName, openingElementClassUtilities } from "./jsx-class-utility.js";
-
-const SLOTS = new Set(["DrawerHeader", "DrawerBody", "DrawerFooter"]);
-
-const EDGE = /^border(?:-[tby])?(?:-\d+)?$/;
-
-function edgeUtility(node, context) {
-  return openingElementClassUtilities(node, context).find((utility) =>
-    EDGE.test(utility.split(":").at(-1).replace(/^!/, "")),
-  );
-}
-
-function wrappedSlot(element, context) {
-  for (const child of element.children) {
-    if (child.type !== "JSXElement") continue;
-    const name = jsxComponentName(child.openingElement, context);
-    if (name && SLOTS.has(name)) return name;
-  }
-  return undefined;
-}
-
-export const drawerOwnsItsEdges = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Keep the edges between a drawer's header, body and footer with the drawer",
-    },
-    schema: [],
-    messages: {
-      slotEdge:
-        '"{{utility}}" gives <{{slot}}> a second edge. The drawer draws the hairline between its header, its body and its footer; drop the border class (rule/drawer-owns-its-edges).',
-      wrapperEdge:
-        '"{{utility}}" draws an edge around <{{slot}}>. The drawer draws the hairline between its header, its body and its footer; render the slot without this wrapper (rule/drawer-owns-its-edges).',
-    },
-  },
-  create(context) {
-    return {
-      JSXElement(element) {
-        const utility = edgeUtility(element.openingElement, context);
-        if (!utility) return;
-        const own = jsxComponentName(element.openingElement, context);
-        if (own && SLOTS.has(own)) {
-          context.report({
-            node: element.openingElement,
-            messageId: "slotEdge",
-            data: { utility, slot: own },
-          });
-          return;
-        }
-        const slot = wrappedSlot(element, context);
-        if (slot) {
-          context.report({
-            node: element.openingElement,
-            messageId: "wrapperEdge",
-            data: { utility, slot },
-          });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/expect-chain.js

@@ -1,60 +0,0 @@
-/*
- * One reader for `expect(subject).<modifiers>.<matcher>(args)`.
- *
- * Both assertion rules here judge a call by its matcher name, and the matcher
- * is not the callee's property in the general case: `not`, `resolves` and
- * `rejects` sit between `expect(...)` and the matcher, so the name has to be
- * read by walking the member chain back to the `expect` call. This is that
- * walk, kept in one place so the two rules cannot disagree about what counts
- * as an assertion.
- */
-
-function propertyName(member) {
-  if (!member.computed && member.property.type === "Identifier") return member.property.name;
-  if (member.computed && member.property.type === "Literal") {
-    return typeof member.property.value === "string" ? member.property.value : undefined;
-  }
-  return undefined;
-}
-
-/** `a?.b` and `a?.()` arrive wrapped; the rules want the expression itself. */
-function unwrapChain(node) {
-  return node?.type === "ChainExpression" ? node.expression : node;
-}
-
-function isExpectCall(node) {
-  if (node?.type !== "CallExpression") return false;
-  if (node.callee.type === "Identifier") return node.callee.name === "expect";
-  // `expect.soft(value)` and `expect.poll(fn)` open the same chain.
-  return node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier"
-    ? node.callee.object.name === "expect"
-    : false;
-}
-
-/**
- * Reads an assertion call. Returns `{ matcher, modifiers, subject, args }` for
- * `expect(subject).<modifiers>.<matcher>(args)`, or `undefined` when the call
- * is not an `expect` chain. `subject` is unwrapped of its `ChainExpression`.
- */
-export function expectAssertion(node) {
-  if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") return undefined;
-  const matcher = propertyName(node.callee);
-  if (!matcher) return undefined;
-
-  const modifiers = [];
-  let current = node.callee.object;
-  while (current.type === "MemberExpression") {
-    const name = propertyName(current);
-    if (!name) return undefined;
-    modifiers.unshift(name);
-    current = current.object;
-  }
-  if (!isExpectCall(current)) return undefined;
-
-  return {
-    matcher,
-    modifiers,
-    subject: unwrapChain(current.arguments[0]),
-    args: node.arguments,
-  };
-}

package/dist/eslint/rules/icon-control-accessible-name.js

@@ -1,156 +0,0 @@
-/*
- * A control whose whole content is an icon still has to say what it does.
- *
- * An icon is a picture, and a screen reader announces "button" and nothing else
- * for one. Sighted readers recover the meaning from the glyph; a screen-reader
- * user, and anyone addressing the control by name through voice control, gets an
- * unnamed button. The name comes from `aria-label`, from `aria-labelledby`, or
- * from text inside the control that is hidden visually rather than from the
- * accessibility tree — the `sr-only` span this repository already writes beside
- * its close buttons. That last spelling needs no separate test here: hidden text
- * is text, so a control carrying one is not icon-only in the first place.
- *
- * `title` is NOT one of them. It does name the control for most screen readers,
- * but it also mints a browser tooltip, and the copy contract (the Tooltip
- * contract in `skills/design/product-design/references/copy.md`) says the title
- * attribute is not this product's help system. Accepting it here would make the
- * rule push authors toward the one tooltip the design system refuses.
- *
- * Two shapes are icon-only, and both are read off the element rather than out of
- * a list: a `Button` on one of the icon size variants (`icon`, `icon-xs`,
- * `icon-sm`, `icon-lg`), and any `Button` or `button` whose children render
- * elements and no text at all.
- *
- * Two shapes are deliberately out of scope. A `Button` written as the value of a
- * `render` prop is a STYLE carrier: the primitive that receives it owns the
- * rendered element's children and its label, as `<DropdownMenuTrigger
- * aria-label={label} render={<Button size="icon-sm" />}>` does in
- * `packages/ui/src/components/action-menu.tsx`, so the name is not this element's
- * to carry. An element with a `{...props}` spread may be handed a label by its
- * caller, and this rule does not guess what a spread holds.
- *
- * Standard tool checked first: the root config runs jsx-a11y's `alt-text`,
- * `aria-props`, `aria-proptypes`, `aria-unsupported-elements`,
- * `role-has-required-aria-props` and `role-supports-aria-props`, and Next's
- * core-web-vitals config adds no more. Every one of them judges an attribute
- * that is already present; none asks whether a control has a name at all.
- * `control-has-associated-label` is the upstream rule that would, and it is
- * enabled nowhere, looks for a label element rather than an accessible name, and
- * knows nothing about a size variant that means "icon".
- */
-import { jsxComponentName } from "./jsx-class-utility.js";
-
-const CONTROL_TAGS = new Set(["Button", "button"]);
-const ICON_SIZES = new Set(["icon", "icon-xs", "icon-sm", "icon-lg"]);
-const NAME_ATTRIBUTES = new Set(["aria-label", "aria-labelledby"]);
-
-function attributeName(attribute) {
-  return attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier"
-    ? attribute.name.name
-    : undefined;
-}
-
-/** The literal string an attribute carries, or undefined for anything computed. */
-function literalAttributeValue(openingElement, name) {
-  for (const attribute of openingElement.attributes) {
-    if (attributeName(attribute) !== name) continue;
-    const value = attribute.value;
-    return value?.type === "Literal" && typeof value.value === "string" ? value.value : undefined;
-  }
-  return undefined;
-}
-
-/** True when this element stands in for another primitive's rendered element. */
-function isRenderProp(node, sourceCode) {
-  return sourceCode.getAncestors(node).some((ancestor) => attributeName(ancestor) === "render");
-}
-
-/*
- * Whether an expression can only ever evaluate to JSX or to nothing. `{label}`
- * and `{day.getDate()}` are text; `{copied ? <Check /> : <Copy />}` is not.
- */
-function producesOnlyElements(expression) {
-  switch (expression.type) {
-    case "JSXEmptyExpression":
-    case "JSXElement":
-    case "JSXFragment":
-      return true;
-    case "ConditionalExpression":
-      return (
-        producesOnlyElements(expression.consequent) && producesOnlyElements(expression.alternate)
-      );
-    case "LogicalExpression":
-      return producesOnlyElements(expression.right);
-    case "Literal":
-      return expression.value === null || expression.value === false;
-    case "Identifier":
-      return expression.name === "undefined";
-    default:
-      return false;
-  }
-}
-
-/** Whether a subtree renders any text, visible or visually hidden. */
-function rendersText(node) {
-  for (const child of node.children ?? []) {
-    if (child.type === "JSXText") {
-      if (child.value.trim() !== "") return true;
-      continue;
-    }
-    if (child.type === "JSXElement" || child.type === "JSXFragment") {
-      if (rendersText(child)) return true;
-      continue;
-    }
-    if (child.type === "JSXExpressionContainer" && !producesOnlyElements(child.expression)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-/** Whether a subtree renders at least one element of its own. */
-function rendersElement(node) {
-  return (node.children ?? []).some(
-    (child) =>
-      child.type === "JSXElement" ||
-      child.type === "JSXFragment" ||
-      (child.type === "JSXExpressionContainer" &&
-        child.expression.type !== "JSXEmptyExpression" &&
-        producesOnlyElements(child.expression)),
-  );
-}
-
-export const iconControlAccessibleName = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require an accessible name on a control whose only content is an icon",
-    },
-    schema: [],
-    messages: {
-      unnamedIconControl:
-        'A screen reader announces "{{tag}}" and nothing more for this control: its content is an icon, and an icon carries no name. Add aria-label with the action it performs, point aria-labelledby at the text that names it, or put that text in a child with the sr-only class.',
-    },
-  },
-  create(context) {
-    return {
-      JSXOpeningElement(node) {
-        const tag = jsxComponentName(node, context);
-        if (!tag || !CONTROL_TAGS.has(tag)) return;
-        if (node.attributes.some((attribute) => attribute.type === "JSXSpreadAttribute")) return;
-        if (
-          node.attributes.some((attribute) => NAME_ATTRIBUTES.has(attributeName(attribute) ?? ""))
-        )
-          return;
-        if (isRenderProp(node, context.sourceCode)) return;
-
-        const element = node.parent;
-        const iconSized = ICON_SIZES.has(literalAttributeValue(node, "size") ?? "");
-        if (!iconSized && !rendersElement(element)) return;
-        if (rendersText(element)) return;
-
-        context.report({ node, messageId: "unnamedIconControl", data: { tag } });
-      },
-    };
-  },
-};