@nadicodeai/ui 12.1.54 → 12.1.56

package/dist/eslint/rules/prefer-radio-for-few-static-options.js

@@ -1,77 +0,0 @@
-/*
- * A short fixed set of choices is shown, not hidden.
- *
- * A `Select` spends a click and a popup to reveal what it holds. That trade pays
- * for itself over a long or a loaded list; it does not pay for two or three
- * options that are known at author time, where the popup costs the reader the
- * one thing they came for — seeing what the alternatives are — and costs the
- * keyboard user an open-then-arrow instead of a single arrow.
- *
- * The count has to be STATIC to be a finding. A `SelectContent` filled from
- * `{items.map(...)}` holds however many rows the data has today, so its shape is
- * not this rule's business and any expression child stands the rule down.
- *
- * Standard tool checked first: `no-restricted-syntax` can select a
- * `SelectContent`, but not one whose children are exactly two or three elements
- * of one name and nothing dynamic. That is a property of the subtree, so it is
- * read here.
- */
-import { jsxComponentName } from "./jsx-class-utility.js";
-
-const CONTENT_TAG = "SelectContent";
-const ITEM_TAG = "SelectItem";
-
-/*
- * The items one content subtree renders, and whether anything in it is computed.
- * Groups and separators are descended through; an item's own children are not,
- * because a label built from a variable says nothing about how many items there
- * are. Attributes are out of scope for the same reason: `value={option.value}`
- * on a hand-written item is ordinary.
- */
-function scanContent(node, context, found) {
-  for (const child of node.children) {
-    if (child.type === "JSXExpressionContainer") {
-      if (child.expression.type !== "JSXEmptyExpression") found.dynamic = true;
-      continue;
-    }
-    if (child.type === "JSXFragment") {
-      scanContent(child, context, found);
-      continue;
-    }
-    if (child.type !== "JSXElement") continue;
-    if (jsxComponentName(child.openingElement, context) === ITEM_TAG) {
-      found.items.push(child);
-      continue;
-    }
-    scanContent(child, context, found);
-  }
-  return found;
-}
-
-export const preferRadioForFewStaticOptions = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Prefer RadioGroup over Select for two or three statically written options",
-    },
-    schema: [],
-    messages: {
-      fewStaticOptions:
-        "This Select holds {{count}} options fixed at author time, so a reader has to open it to learn what the alternatives are. RadioGroup shows all {{count}} at once and takes one arrow key instead of an open and an arrow. Use RadioGroup with a RadioGroupItem per option.",
-    },
-  },
-  create(context) {
-    return {
-      JSXElement(node) {
-        if (jsxComponentName(node.openingElement, context) !== CONTENT_TAG) return;
-        const { items, dynamic } = scanContent(node, context, { items: [], dynamic: false });
-        if (dynamic || items.length < 2 || items.length > 3) return;
-        context.report({
-          node: node.openingElement,
-          messageId: "fewStaticOptions",
-          data: { count: String(items.length) },
-        });
-      },
-    };
-  },
-};

package/dist/eslint/rules/settings-section-description.js

@@ -1,45 +0,0 @@
-/*
- * Every settings section says what it changes.
- *
- * DESIGN.md ("Cards and sections") gives a settings section a one-line
- * description under its title, the line that tells a person what changing the
- * fields below will do before they change them. The failure this catches: the
- * Portal's Profile photo and Personal details sections, whose titles named the
- * content and nothing said what the change reaches.
- *
- * What is read is a `SettingsSection` element and whether it passes a
- * `description` attribute. A spread may carry one, so an element with a spread
- * attribute is not reported.
- *
- * Standard tool checked first: `no-restricted-syntax` can select
- * `JSXOpeningElement[name.name="SettingsSection"]:not(:has(JSXAttribute[name.name="description"]))`,
- * but not through a renamed import, which `jsxComponentName` resolves.
- */
-import { jsxComponentName } from "./jsx-class-utility.js";
-
-export const settingsSectionDescription = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require a one-line description on every SettingsSection",
-    },
-    schema: [],
-    messages: {
-      missingDescription:
-        'This SettingsSection has no description. Say in one line what changing it does, under its title (DESIGN.md "Cards and sections", rule/settings-section-described).',
-    },
-  },
-  create(context) {
-    return {
-      JSXOpeningElement(node) {
-        if (jsxComponentName(node, context) !== "SettingsSection") return;
-        const described = node.attributes.some(
-          (attribute) =>
-            attribute.type === "JSXSpreadAttribute" ||
-            (attribute.name?.type === "JSXIdentifier" && attribute.name.name === "description"),
-        );
-        if (!described) context.report({ node, messageId: "missingDescription" });
-      },
-    };
-  },
-};

package/dist/eslint/rules/shadcn-composition.js

@@ -1,197 +0,0 @@
-/*
- * The composition conventions the shared components are built to, checked
- * where they are composed:
- *
- * - an overlay carries its title, so a screen reader announces what opened
- *   (`className="sr-only"` when the title is not drawn);
- * - a `SelectItem` sits inside a `SelectGroup`, which is what gives the listbox
- *   its accessible grouping;
- * - an `AvatarImage` has an `AvatarFallback` beside it, or the avatar is blank
- *   until the image loads;
- * - a lucide icon inside a `Button` carries `data-icon`, the hook the button's
- *   own spacing rules key on;
- * - a settings submit action uses SettingsSection's shared footer, so each
- *   caller cannot rebuild its own divider, padding, and action position;
- * - the label and description beside a control in a `Field` sit in
- *   `FieldContent`, the slot a horizontal field keys on to align its checkbox
- *   with the first line of text rather than the middle of the block.
- *
- * Standard tool checked first: `jsx-a11y` covers roles and ARIA on
- * intrinsic elements and says nothing about these composed components;
- * `no-restricted-syntax` selects a node by its own shape, and every one of
- * these is a statement about an ancestor or a descendant. Replaces the JSX half
- * of the retired @nadicodeai/ui composition-conventions scanner (#822); stock
- * upstream shapes carry an inline disable with the reason at the site.
- */
-import {
-  jsxComponentName,
-  packageOwnedPrimitivesSchema,
-  skipsPackageOwnedPrimitive,
-} from "./jsx-class-utility.js";
-
-const OVERLAY_TITLES = {
-  AlertDialogContent: "AlertDialogTitle",
-  DialogContent: "DialogTitle",
-  DrawerContent: "DrawerTitle",
-  SheetContent: "SheetTitle",
-};
-
-function elementName(node) {
-  if (node?.type === "JSXElement") return elementName(node.openingElement);
-  if (node?.type !== "JSXOpeningElement") return undefined;
-  if (node.name.type === "JSXIdentifier") return node.name.name;
-  if (node.name.type === "JSXMemberExpression") return node.name.property.name;
-  return undefined;
-}
-
-function hasAttribute(node, attributeName) {
-  return node.attributes.some(
-    (attribute) =>
-      attribute.type === "JSXAttribute" &&
-      attribute.name.type === "JSXIdentifier" &&
-      attribute.name.name === attributeName,
-  );
-}
-
-/**
- * True when `tagName` is rendered anywhere below this element — through a
- * conditional or a map as much as directly, so the whole subtree is walked
- * rather than the JSX children alone.
- */
-function hasDescendant(node, tagName, root = node) {
-  if (!node || typeof node.type !== "string") return false;
-  if (node !== root && node.type === "JSXElement" && elementName(node) === tagName) return true;
-  for (const [key, value] of Object.entries(node)) {
-    if (key === "parent") continue;
-    if (Array.isArray(value)) {
-      if (value.some((child) => hasDescendant(child, tagName, root))) return true;
-    } else if (value && typeof value === "object" && hasDescendant(value, tagName, root)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-function ancestorNames(node, sourceCode) {
-  return sourceCode
-    .getAncestors(node)
-    .filter((ancestor) => ancestor.type === "JSXElement")
-    .map((ancestor) => elementName(ancestor))
-    .filter(Boolean);
-}
-
-/** A FieldLabel or FieldDescription grouped in a plain element directly inside a Field. */
-function fieldTextOutsideContent(node) {
-  const tag = elementName(node);
-  if (tag !== "FieldLabel" && tag !== "FieldDescription") return false;
-  const group = node.parent?.parent;
-  if (group?.type !== "JSXElement") return false;
-  const groupName = elementName(group);
-  if (!groupName || groupName[0] !== groupName[0].toLowerCase()) return false;
-  const field = group.parent;
-  return field?.type === "JSXElement" && elementName(field) === "Field";
-}
-
-function isIconTag(tagName) {
-  return tagName === "Icon" || tagName.endsWith("Icon");
-}
-
-function misplacedSettingsSubmit(node, context) {
-  if (jsxComponentName(node, context) !== "Button") return false;
-  const attribute = node.attributes.find(
-    (entry) => entry.type === "JSXAttribute" && entry.name.name === "type",
-  );
-  const value =
-    attribute?.value?.type === "JSXExpressionContainer"
-      ? attribute.value.expression
-      : attribute?.value;
-  const type =
-    value?.type === "TemplateLiteral" && value.expressions.length === 0
-      ? value.quasis[0]?.value.cooked
-      : value?.value;
-  if (type !== "submit") return false;
-  const ancestors = context.sourceCode.getAncestors(node);
-  const section = ancestors.findLast(
-    (ancestor) =>
-      ancestor.type === "JSXElement" &&
-      jsxComponentName(ancestor.openingElement, context) === "SettingsSection",
-  );
-  if (!section) return false;
-  return !ancestors.slice(ancestors.indexOf(section) + 1).some((ancestor) => {
-    if (ancestor.type === "JSXAttribute")
-      return ancestor.name.name === "footer" && ancestor.parent === section.openingElement;
-    return (
-      ancestor.type === "JSXElement" &&
-      ["DialogContent", "DrawerContent", "AlertDialogContent"].includes(
-        jsxComponentName(ancestor.openingElement, context),
-      )
-    );
-  });
-}
-
-export const shadcnComposition = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require the shadcn primitives' composition conventions where they are composed",
-    },
-    schema: [packageOwnedPrimitivesSchema],
-    messages: {
-      overlayTitle:
-        '{{tag}} must include {{title}}; use className="sr-only" when the title is visually hidden.',
-      selectGroup: "SelectItem must be rendered inside SelectGroup.",
-      avatarFallback: "AvatarImage requires an AvatarFallback in the same Avatar.",
-      buttonIcon: "An icon inside Button must carry data-icon.",
-      settingsFooter:
-        "Put a SettingsSection submit action in its footer prop; the shared component owns the divider, spacing, and action position.",
-      fieldContent:
-        "Group a Field's label and description in FieldContent, not a plain element; a horizontal Field aligns its control to the text through that slot.",
-    },
-  },
-  create(context) {
-    if (skipsPackageOwnedPrimitive(context)) {
-      return {};
-    }
-
-    return {
-      JSXOpeningElement(node) {
-        const tag = elementName(node);
-        if (!tag) return;
-        const element = node.parent;
-
-        if (misplacedSettingsSubmit(node, context)) {
-          context.report({ node, messageId: "settingsFooter" });
-        }
-
-        if (fieldTextOutsideContent(node)) {
-          context.report({ node, messageId: "fieldContent" });
-        }
-
-        const title = OVERLAY_TITLES[tag];
-        if (title && !hasDescendant(element, title)) {
-          context.report({ node, messageId: "overlayTitle", data: { tag, title } });
-        }
-
-        if (tag === "Avatar" && hasDescendant(element, "AvatarImage")) {
-          if (!hasDescendant(element, "AvatarFallback")) {
-            context.report({ node, messageId: "avatarFallback" });
-          }
-          return;
-        }
-
-        if (tag !== "SelectItem" && tag !== "AvatarImage" && !isIconTag(tag)) return;
-
-        const ancestors = ancestorNames(node, context.sourceCode);
-        if (tag === "SelectItem" && !ancestors.includes("SelectGroup")) {
-          context.report({ node, messageId: "selectGroup" });
-        }
-        if (tag === "AvatarImage" && !ancestors.includes("Avatar")) {
-          context.report({ node, messageId: "avatarFallback" });
-        }
-        if (isIconTag(tag) && ancestors.includes("Button") && !hasAttribute(node, "data-icon")) {
-          context.report({ node, messageId: "buttonIcon" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/table-column-wraps-by-meta.js

@@ -1,55 +0,0 @@
-/*
- * A table column wraps by its definition, never by its cells. DataTable holds a
- * fact on one line and gives a column marked `meta: { prose: true }` a floor
- * and wrapping between words (DESIGN.md, "Tables and missing values"). A cell
- * that sets its own wrapping gets neither the floor nor the identity's share
- * of the width, and the table squeezes it until each word takes a line.
- *
- * Standard tool checked first: `better-tailwindcss`'s `no-restricted-classes`
- * judges one class at a time, and `whitespace-normal` is right in a button or a
- * card. What is wrong is where it is written: inside a column's `cell`, which
- * this rule reads on the shared className reader.
- */
-import { openingElementClassUtilities } from "./jsx-class-utility.js";
-
-const WRAPPING = /^(?:.*:)?whitespace-(?:normal|pre-line|pre-wrap)$/;
-
-/** Inside the `cell` renderer of a column definition object. */
-function insideColumnCell(node) {
-  for (let current = node.parent; current; current = current.parent) {
-    if (
-      current.type === "Property" &&
-      !current.computed &&
-      current.key.type === "Identifier" &&
-      current.key.name === "cell"
-    ) {
-      return true;
-    }
-  }
-  return false;
-}
-
-export const tableColumnWrapsByMeta = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow a table cell setting its own wrapping; mark the column prose",
-    },
-    schema: [],
-    messages: {
-      cellWraps:
-        '"{{token}}" wraps one cell of a table column. Mark the column `meta: { prose: true }` so DataTable gives it a floor and wraps it between words.',
-    },
-  },
-  create(context) {
-    return {
-      JSXOpeningElement(node) {
-        if (!insideColumnCell(node)) return;
-        for (const token of openingElementClassUtilities(node, context)) {
-          if (WRAPPING.test(token))
-            context.report({ node, messageId: "cellWraps", data: { token } });
-        }
-      },
-    };
-  },
-};