@nadicodeai/ui 12.1.54 → 12.1.56

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

package/dist/eslint/rules/menu-command-owner.js

@@ -1,45 +0,0 @@
-import { jsxComponentName } from "./jsx-class-utility.js";
-
-export const menuCommandOwner = {
-  meta: {
-    type: "problem",
-    docs: { description: "Keep command labels and icons in the shared menu composition." },
-    schema: [],
-    messages: {
-      command:
-        "Use DropdownMenuCommand with its required icon; it owns readable labels and trailing icon layout. DropdownMenuItem is only for an iconOnly control here.",
-      trigger:
-        "Use ActionMenu for three-dot commands so placement, naming, and popup behavior have one owner.",
-    },
-  },
-  create(context) {
-    return {
-      JSXOpeningElement(node) {
-        const name = jsxComponentName(node, context);
-        if (
-          name === "DropdownMenuItem" &&
-          !node.attributes.some(
-            (attribute) =>
-              attribute.type === "JSXAttribute" &&
-              attribute.name.name === "iconOnly" &&
-              (attribute.value === null ||
-                (attribute.value.type === "JSXExpressionContainer" &&
-                  attribute.value.expression.value === true)),
-          )
-        )
-          context.report({ node, messageId: "command" });
-        if (
-          [
-            "Ellipsis",
-            "EllipsisIcon",
-            "EllipsisVertical",
-            "MoreHorizontal",
-            "MoreVertical",
-          ].includes(name)
-        ) {
-          context.report({ node, messageId: "trigger" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-bare-page-navigation.js

@@ -1,46 +0,0 @@
-/*
- * The Portal's browser suite navigates through `tests/support/hydration.ts`.
- * `page.goto` and `page.reload` resolve while React is still hydrating, and the
- * interaction a spec dispatches next lands on server markup the shell is about
- * to replace: #2173 lost six open menus that way, #2776 clicked "Create team"
- * on a page that had not taken over yet, and #2837 read a prefetch as a
- * refresh. `back` and `forward` are outside the rule, because they restore a
- * tree the client already owns rather than loading a document.
- */
-
-const NAVIGATIONS = new Map([
-  ["goto", "bareGoto"],
-  ["reload", "bareReload"],
-]);
-
-function propertyName(member) {
-  if (member.computed) return member.property.type === "Literal" ? member.property.value : null;
-  return member.property.type === "Identifier" ? member.property.name : null;
-}
-
-export const noBarePageNavigation = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Disallow a bare page.goto or page.reload in the Portal's browser suite; navigate through the helper that waits for the shell to hydrate",
-    },
-    schema: [],
-    messages: {
-      bareGoto:
-        "`goto()` resolves before React hydrates the page, so the next click or keypress lands on server markup the shell is about to replace (#2173, #2776, #2837). Open the page with `gotoPortal` from `tests/support/hydration`, which waits for the shell's `data-hydrated`, or with `gotoOutsideShell` for an address the dashboard shell never renders, such as login, signup or an app's consent page.",
-      bareReload:
-        "`reload()` resolves before React hydrates the page, so the next click or keypress lands on server markup the shell is about to replace (#2776). Reload with `reloadPortal` from `tests/support/hydration`, which waits for the shell's `data-hydrated`.",
-    },
-  },
-
-  create(context) {
-    return {
-      CallExpression(node) {
-        if (node.callee.type !== "MemberExpression") return;
-        const messageId = NAVIGATIONS.get(propertyName(node.callee));
-        if (messageId) context.report({ node, messageId });
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-elevated-edge.js

@@ -1,141 +0,0 @@
-/*
- * An elevated surface draws its own edge. `nc-elevation-*` paints the rung's
- * whole recipe, whose last layer is its own optical ring (DESIGN.md,
- * "core.elevation"), so a border or a second ring on the same target paints a
- * second edge over it: the seam this repository keeps reintroducing when a
- * stock shadcn shape is pasted next to an elevation.
- *
- * Standard tool checked first: `better-tailwindcss`'s
- * `no-restricted-classes` judges one class at a time. `border` and `ring-1` are
- * legal on their own — they are wrong only beside an elevation, and only when
- * both land on the same target, so `*:data-[slot=input]:border-input` under an
- * elevated parent stays legal. That relationship is what this rule reads, on
- * the shared className reader.
- *
- * Replaces the @nadicodeai/ui material-surface-contract scanner (#822), which
- * built its own TypeScript AST over the package's sources to ask the same
- * question. It takes no `packageOwnedPrimitives` option: the material ladder
- * holds wherever an elevation is written, inside the package and out.
- */
-import { nodeClassUtilities } from "./jsx-class-utility.js";
-
-const ELEVATION = /^nc-elevation-(?:resting|raised|floating|modal)$/;
-
-/*
- * The callees that compose a class list out of several strings. A class written
- * in one argument and an elevation in another are one surface, so the call —
- * not the string — is the unit this rule reviews.
- */
-const COMPOSERS = new Set(["cn", "clsx", "cva"]);
-
-/** `md:hover:border` → `{ modifiers: ["md", "hover"], utility: "border" }`. */
-function tailwindToken(token) {
-  const segments = [];
-  let bracketDepth = 0;
-  let start = 0;
-  for (let index = 0; index < token.length; index += 1) {
-    const character = token[index];
-    if (character === "[") bracketDepth += 1;
-    if (character === "]") bracketDepth = Math.max(0, bracketDepth - 1);
-    // A colon inside brackets belongs to an arbitrary value, not to a variant.
-    if (character === ":" && bracketDepth === 0) {
-      segments.push(token.slice(start, index));
-      start = index + 1;
-    }
-  }
-  segments.push(token.slice(start));
-  return { modifiers: segments.slice(0, -1), utility: segments.at(-1) ?? token };
-}
-
-/**
- * What a utility paints on: the element itself, or the descendants a variant
- * selects. Two utilities collide only when this matches — an elevation on the
- * root and a border on `*:data-[slot=input]` are different surfaces.
- */
-function targetKey(modifiers) {
-  const descendants = modifiers.filter(
-    (modifier) => modifier === "*" || modifier === "**" || /^\[&(?:_|>|\s)/.test(modifier),
-  );
-  return descendants.length === 0 ? "self" : descendants.join(":");
-}
-
-/** A width of zero is the absence of an edge, which is what an elevation wants. */
-function isZeroWidthUtility(utility) {
-  return utility === "border-0" || utility === "ring-0";
-}
-
-function edgeRule(utility) {
-  if (/^border(?:$|-)/.test(utility) && !isZeroWidthUtility(utility)) return "borderWithElevation";
-  if (/^ring(?:$|-)/.test(utility) && !isZeroWidthUtility(utility)) return "ringWithElevation";
-  return undefined;
-}
-
-/** One finding per offending edge, however many elevations it sits beside. */
-function edgeViolations(classes) {
-  const tokens = classes.map((token) => ({ token, ...tailwindToken(token) }));
-  const elevations = tokens.filter(({ utility }) => ELEVATION.test(utility));
-  const violations = new Map();
-  for (const elevation of elevations) {
-    const elevationTarget = targetKey(elevation.modifiers);
-    for (const candidate of tokens) {
-      if (targetKey(candidate.modifiers) !== elevationTarget) continue;
-      const messageId = edgeRule(candidate.utility);
-      if (messageId && !violations.has(candidate.token)) {
-        violations.set(candidate.token, { messageId, shadow: elevation.token });
-      }
-    }
-  }
-  return [...violations].map(([token, finding]) => ({ token, ...finding }));
-}
-
-function isComposerCall(node) {
-  return (
-    node?.type === "CallExpression" &&
-    node.callee.type === "Identifier" &&
-    COMPOSERS.has(node.callee.name)
-  );
-}
-
-function insideComposerCall(node) {
-  for (let current = node.parent; current; current = current.parent) {
-    if (isComposerCall(current)) return true;
-  }
-  return false;
-}
-
-export const noElevatedEdge = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Disallow a border or a second ring on the same target as an nc-elevation-* utility",
-    },
-    schema: [],
-    messages: {
-      borderWithElevation:
-        '"{{token}}" draws a hard border on the same target as {{shadow}}. An elevated surface carries its own optical ring: drop the border, or drop the elevation.',
-      ringWithElevation:
-        '"{{token}}" draws a second ring on the same target as {{shadow}}. An elevated surface carries its own optical ring already.',
-    },
-  },
-  create(context) {
-    const report = (node, classes) => {
-      for (const { token, messageId, shadow } of edgeViolations(classes)) {
-        context.report({ node, messageId, data: { token, shadow } });
-      }
-    };
-
-    return {
-      CallExpression(node) {
-        // The outermost composer owns the surface: a nested one's strings are
-        // already in its list, so reviewing both would report twice.
-        if (!isComposerCall(node) || insideComposerCall(node)) return;
-        report(node, nodeClassUtilities(node, context, { skipPropertyKeys: true }));
-      },
-      Literal(node) {
-        if (typeof node.value !== "string" || insideComposerCall(node)) return;
-        report(node, node.value.split(/\s+/).filter(Boolean));
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-existence-only-assertion.js

@@ -1,89 +0,0 @@
-/*
- * An assertion that something exists is not an assertion about behavior.
- *
- * Two shapes in this suite pass for nearly any implementation.
- *
- * A `&&` or `||` subject returns one of its operands, not a boolean, so the
- * short-circuit alone can satisfy the matcher: the left operand decides the
- * result and the right one is never evaluated.
- *
- * An optional call yields `undefined` when the method is gone. That is exactly
- * what `toBeFalsy()` and `toBeUndefined()` accept, which is how
- * `expect(options.clientPrivileges?.()).toBeFalsy()` in
- * `apps/portal/src/lib/server/nadia-oauth-provider.test.ts` kept asserting that
- * OAuth grants no configuration privileges after the privilege hooks had been
- * deleted from the provider.
- *
- * What is deliberately left alone: `toBeDefined()` / `toBeTruthy()` on any
- * other subject. On a plain identifier or member read it is the type-narrowing
- * step before reading a property off it. On a Testing Library `getBy*` query it
- * is redundant, since the query already throws, but it is the suite's idiom for
- * "this element renders" and replacing it mechanically produces
- * `expect(getByText("X").textContent).toBe("X")`, which is a tautology of its
- * own: 214 such sites were rewritten that way once and reverted. `toBeNull()`
- * and `toBeUndefined()` on any other subject are a real claim of absence.
- *
- * Standard tools checked first: `vitest/expect-expect` refuses a test with no
- * assertion at all and `vitest/valid-expect` checks the call's arity; neither
- * asks what the asserted expression can produce, which is the whole question
- * here.
- */
-import { expectAssertion } from "./expect-chain.js";
-
-const SHORT_CIRCUIT_MATCHERS = new Set(["toBeDefined", "toBeTruthy", "toBeFalsy", "toBeUndefined"]);
-const MISSING_VALUE_MATCHERS = new Set(["toBeFalsy", "toBeUndefined"]);
-
-function isOptionalCall(node) {
-  return node?.type === "CallExpression" && node.optional === true;
-}
-
-export const noExistenceOnlyAssertion = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Disallow expectations that only assert a value exists, which pass for almost any implementation",
-    },
-    schema: [],
-    messages: {
-      shortCircuitSubject:
-        "`{{operator}}` returns one of its operands rather than a boolean, so `{{assertion}}` passes on the short-circuit alone, with the right operand never evaluated. Assert each operand separately, or assert the value the expression stands for.",
-      optionalCallAbsence:
-        "`{{assertion}}` on an optional call passes when the call never happens: a deleted or renamed method makes `?.()` yield `undefined`, which is both falsy and undefined. Assert the method is present, then assert what the call returns.",
-    },
-  },
-
-  create(context) {
-    function assertionText(matcher, modifiers) {
-      return [...modifiers, `${matcher}()`].join(".");
-    }
-
-    return {
-      CallExpression(node) {
-        const assertion = expectAssertion(node);
-        if (!assertion) return;
-        const { matcher, modifiers, subject } = assertion;
-        if (!subject) return;
-
-        if (modifiers.length > 0) return;
-
-        if (subject.type === "LogicalExpression" && SHORT_CIRCUIT_MATCHERS.has(matcher)) {
-          context.report({
-            node,
-            messageId: "shortCircuitSubject",
-            data: { operator: subject.operator, assertion: assertionText(matcher, modifiers) },
-          });
-          return;
-        }
-
-        if (isOptionalCall(subject) && MISSING_VALUE_MATCHERS.has(matcher)) {
-          context.report({
-            node,
-            messageId: "optionalCallAbsence",
-            data: { assertion: assertionText(matcher, modifiers) },
-          });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-invalid-token-utility.js

@@ -1,46 +0,0 @@
-import { createRequire } from "node:module";
-
-import { tokenUtilityVisitors } from "./jsx-class-utility.js";
-
-const require = createRequire(import.meta.url);
-const generatedTheme = require("@nadicodeai/design-system/tailwind").theme.extend;
-const typographyUtilities = new Set(
-  Object.keys(generatedTheme.fontSize).map((name) => `nc-type-${name}`),
-);
-const colorTokens = new Set(Object.keys(generatedTheme.colors));
-const COLOR_UTILITY =
-  /^(?:bg|text|border|outline|ring|fill|stroke|decoration|accent|caret|divide|from|via|to|shadow)-nc-([^/]+)(?:\/.*)?$/;
-
-function withoutVariants(utility) {
-  return utility.slice(utility.lastIndexOf(":") + 1);
-}
-
-function isInvalidGeneratedUtility(utility) {
-  const unqualified = withoutVariants(utility);
-  if (unqualified.startsWith("nc-type-")) {
-    return !typographyUtilities.has(unqualified);
-  }
-
-  const color = COLOR_UTILITY.exec(unqualified);
-  return color ? !colorTokens.has(color[1]) : false;
-}
-
-export const noInvalidTokenUtility = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow token utilities that are absent from generated design-system output",
-    },
-    schema: [],
-    messages: {
-      invalidTokenUtility:
-        "{{utility}} is not generated by the installed nadicode design system. Use a utility from @nadicodeai/design-system/tailwind.",
-    },
-  },
-  create(context) {
-    return tokenUtilityVisitors(context, (node, utility) => {
-      if (!isInvalidGeneratedUtility(utility)) return;
-      context.report({ node, messageId: "invalidTokenUtility", data: { utility } });
-    });
-  },
-};

package/dist/eslint/rules/no-mono-title-register.js

@@ -1,73 +0,0 @@
-/*
- * Design law 9: a title is prose, so it never renders in the mono-caps
- * register. The rule is mechanical because the register is — `font-mono`
- * together with `uppercase` on a slot that carries a title — and everything
- * judgment-bearing stays out of it: an eyebrow, a fact label, an identifier or
- * a marketing label may all be mono, and none of them is a title slot.
- *
- * Standard tool checked first: `better-tailwindcss`'s
- * `no-restricted-classes` judges one class at a time and never against the
- * element it lands on, so it can ban `font-mono` everywhere or nowhere. The
- * register is a PAIR of classes on a TITLE element, which is a relationship —
- * so it lives here, on the shared className reader.
- *
- * Replaces `monoTitleRegisterViolations` in the retired portal page-grammar
- * analyzers (#821).
- */
-import { openingElementClassUtilities } from "./jsx-class-utility.js";
-
-// The kit's title elements plus the hand-written headings.
-const TITLE_TAGS = new Set(["CardTitle", "h1", "h2", "h3", "h4"]);
-const TITLE_SLOT = /-title$/;
-
-function withoutVariants(utility) {
-  return utility.slice(utility.lastIndexOf(":") + 1);
-}
-
-function slotName(node) {
-  for (const attribute of node.attributes) {
-    if (attribute.type !== "JSXAttribute" || attribute.name.name !== "data-slot") continue;
-    const value = attribute.value;
-    if (value?.type === "Literal" && typeof value.value === "string") return value.value;
-    if (
-      value?.type === "JSXExpressionContainer" &&
-      value.expression.type === "Literal" &&
-      typeof value.expression.value === "string"
-    ) {
-      return value.expression.value;
-    }
-  }
-  return undefined;
-}
-
-function isTitleElement(node) {
-  if (node.name.type !== "JSXIdentifier") return false;
-  if (TITLE_TAGS.has(node.name.name)) return true;
-  const slot = slotName(node);
-  return Boolean(slot && TITLE_SLOT.test(slot));
-}
-
-export const noMonoTitleRegister = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow the retired mono-caps register on a title slot (design law 9)",
-    },
-    schema: [],
-    messages: {
-      monoTitle:
-        "A title never renders in the mono-caps register: drop font-mono and uppercase (design law 9).",
-    },
-  },
-  create(context) {
-    return {
-      JSXOpeningElement(node) {
-        if (!isTitleElement(node)) return;
-        const utilities = openingElementClassUtilities(node, context).map(withoutVariants);
-        if (utilities.includes("font-mono") && utilities.includes("uppercase")) {
-          context.report({ node, messageId: "monoTitle" });
-        }
-      },
-    };
-  },
-};