@nadicodeai/ui 12.1.165 → 12.1.166

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

@@ -1,75 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-imports` holds the menu modules
- * and the ellipsis icons (`repo/menu-owner-imports` in the root config's
- * product-composition blocks), but not a destructive `Button` rendered once per
- * row: that is an import binding joined to where its element renders, which no
- * import rule sees and a selector cannot follow through a renamed import.
- */
-import { PACKAGE_BARREL, partOf, renderedImports, staticAttribute } from "./rendered-import.js";
-
-const BUTTON = new Map([
-  [
-    "Button",
-    ["@nadicodeai/ui/components/button", PACKAGE_BARREL].map((from) => ({ from, part: "Button" })),
-  ],
-]);
-
-const FUNCTIONS = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
-const ROW_CALLBACKS = new Set(["map", "flatMap"]);
-const ROW_RENDERERS = new Set(["cell", "command"]);
-const ROW_COMPONENT = /Row$/;
-
-const nameOf = (key) => (key?.type === "Identifier" ? key.name : key?.value);
-
-function drawsOneRecord(fn) {
-  const { parent } = fn;
-  if (
-    parent.type === "CallExpression" &&
-    parent.arguments[0] === fn &&
-    parent.callee.type === "MemberExpression" &&
-    !parent.callee.computed &&
-    ROW_CALLBACKS.has(parent.callee.property.name)
-  ) {
-    return true;
-  }
-  if (parent.type === "Property" && parent.value === fn) {
-    return ROW_RENDERERS.has(nameOf(parent.key));
-  }
-  if (parent.type === "JSXExpressionContainer" && parent.parent.type === "JSXAttribute") {
-    return ROW_RENDERERS.has(parent.parent.name.name);
-  }
-  if (fn.type === "FunctionDeclaration") return ROW_COMPONENT.test(fn.id?.name ?? "");
-  return parent.type === "VariableDeclarator" && ROW_COMPONENT.test(nameOf(parent.id) ?? "");
-}
-
-function insideARow(node) {
-  for (let current = node.parent; current; current = current.parent) {
-    if (FUNCTIONS.has(current.type) && drawsOneRecord(current)) return true;
-  }
-  return false;
-}
-
-export const menuOwner = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A record's destructive command is the last item of its ActionMenu, never a destructive button in its row.",
-    },
-    schema: [],
-    messages: {
-      "row-destructive-button":
-        "A destructive command is the last item of the row's ActionMenu, after a divider.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    return {
-      JSXOpeningElement(node) {
-        if (partOf(importOf(node.name), BUTTON, context.filename) !== "Button") return;
-        if (staticAttribute(node, "variant") !== "destructive") return;
-        if (insideARow(node)) context.report({ node, messageId: "row-destructive-button" });
-      },
-    };
-  },
-};

package/dist/eslint/rules/middle-truncate-placement.js

@@ -1,69 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` descendant selector can
- * match `MiddleTruncate` under an element by name, but not that the name is the
- * design system's import, that the class sits in a `cn(...)` call or a
- * same-file table, nor that the nearest control carries an `aria-label`
- * without a second selector per spelling.
- */
-import { openingElementClassUtilities } from "./jsx-class-utility.js";
-import { renderedImports } from "./rendered-import.js";
-
-const FROM_DESIGN_SYSTEM = /^(@nadicodeai\/ui(\/|$)|@\/|\.)/;
-const CONTROLS = new Set(["Button", "ButtonLink", "TextLink"]);
-const HOST_CONTROLS = new Set(["a", "button"]);
-const NAMING_ATTRIBUTES = new Set(["aria-label", "aria-labelledby"]);
-const TRUNCATING = /^(truncate|text-ellipsis|overflow-ellipsis|line-clamp-(?!none$).+)$/;
-
-const withoutVariants = (utility) => utility.split(":").pop().replace(/^!/, "");
-
-const namesItself = (openingElement) =>
-  openingElement.attributes.some(
-    (attribute) => attribute.type === "JSXAttribute" && NAMING_ATTRIBUTES.has(attribute.name.name),
-  );
-
-export const middleTruncatePlacement = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "MiddleTruncate cuts its own ellipsis and a control around it carries the name.",
-    },
-    schema: [],
-    messages: {
-      "cuts-its-own-ellipsis":
-        "MiddleTruncate cuts its own ellipsis: take it out of the element that also truncates. Inside a control, give the control an aria-label that names its target, since the cut value is not a name.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const designSystemExport = (elementName) => {
-      const imported = importOf(elementName);
-      return imported && FROM_DESIGN_SYSTEM.test(imported.source) ? imported.name : null;
-    };
-    const isControl = ({ name }) =>
-      CONTROLS.has(designSystemExport(name)) ||
-      (name.type === "JSXIdentifier" && HOST_CONTROLS.has(name.name) && !importOf(name));
-    const truncates = (openingElement) =>
-      openingElementClassUtilities(openingElement, context).some((utility) =>
-        TRUNCATING.test(withoutVariants(utility)),
-      );
-
-    return {
-      JSXElement(node) {
-        if (designSystemExport(node.openingElement.name) !== "MiddleTruncate") return;
-        let nearestControl = null;
-        for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
-          if (ancestor.type !== "JSXElement") continue;
-          const { openingElement } = ancestor;
-          if (truncates(openingElement)) {
-            context.report({ node: node.openingElement, messageId: "cuts-its-own-ellipsis" });
-            return;
-          }
-          if (!nearestControl && isControl(openingElement)) nearestControl = openingElement;
-        }
-        if (nearestControl && !namesItself(nearestControl)) {
-          context.report({ node: node.openingElement, messageId: "cuts-its-own-ellipsis" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-app-feature-component.js

@@ -1,100 +0,0 @@
-/*
- * `@nadicodeai/ui` ships standard components. An operator login, a portal
- * activation screen, a customer-credential panel — those are use cases, and a
- * use case in the package is a screen two consumers can never both want. The
- * boundary is named in the app's vocabulary, so the rule reads names: the
- * module's own file name and everything it exports.
- *
- * Standard tool checked first: core `no-restricted-syntax` matches
- * an exported identifier against a regex through esquery, but it is given one
- * node at a time and never the file that node is in — and a module called
- * `activation.tsx` exporting `Banner` is the case the file name is there to
- * catch. `context.filename` is why this is a rule rather than a selector list.
- *
- * The vocabulary itself is configuration, not code: the banned words live in the
- * workspace's eslint config where the package boundary is drawn, and this file
- * holds only the matching. Replaces the @nadicodeai/ui no-app-feature-components
- * scanner (#822), which built a TypeScript AST over the package's components to
- * ask the same question.
- */
-
-/** `OperatorLoginCard` and `operator-login.tsx` both normalise to `operator-login`. */
-function normalizeName(value) {
-  return value
-    .replace(/\.[jt]sx?$/, "")
-    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
-    .replace(/[\s_]+/g, "-")
-    .toLowerCase();
-}
-
-/** The declared names one `export` statement introduces. */
-function exportedNames(node) {
-  if (!node.declaration) {
-    return node.specifiers.map((specifier) => specifier.exported.name ?? specifier.exported.value);
-  }
-  const declaration = node.declaration;
-  if (declaration.type === "VariableDeclaration") {
-    return declaration.declarations
-      .filter((declarator) => declarator.id.type === "Identifier")
-      .map((declarator) => declarator.id.name);
-  }
-  return declaration.id ? [declaration.id.name] : [];
-}
-
-export const noAppFeatureComponent = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow app-owned feature and use-case names in a shared component package",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          names: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: { feature: { type: "string" }, pattern: { type: "string" } },
-              required: ["feature", "pattern"],
-              additionalProperties: false,
-            },
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      appFeature:
-        "{{what}} names the {{feature}} use case. This package ships standard components; compose an app feature inside the consuming app.",
-    },
-  },
-  create(context) {
-    const names = (context.options?.[0]?.names ?? []).map(({ feature, pattern }) => ({
-      feature,
-      pattern: new RegExp(pattern),
-    }));
-    if (names.length === 0) return {};
-
-    const feature = (candidate) =>
-      names.find(({ pattern }) => pattern.test(normalizeName(candidate)))?.feature;
-
-    const report = (node, candidate, what) => {
-      const matched = feature(candidate);
-      if (matched)
-        context.report({ node, messageId: "appFeature", data: { what, feature: matched } });
-    };
-
-    return {
-      Program(node) {
-        const file = context.filename.replaceAll("\\", "/").split("/").at(-1) ?? "";
-        report(node, file, `The module name "${file}"`);
-      },
-      ExportNamedDeclaration(node) {
-        for (const name of exportedNames(node)) {
-          report(node, name, `The export "${name}"`);
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-bare-button-label.js

@@ -1,55 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-syntax` can match a `Button`
- * whose text is "OK", but not whether that `Button` is the package's (an
- * import binding, so a renamed or local one is judged correctly), nor read the
- * same word off a form's `submit={{ label }}`.
- */
-import { keyName, childText, literalText } from "./literal-text.js";
-import { renderedImports } from "./rendered-import.js";
-
-const BUTTONS = new Set(["Button", "ButtonLink"]);
-const BARE = /^(?:submit|ok|okay|confirm)[.!…]*$/i;
-const FROM_DESIGN_SYSTEM = /^(@nadicodeai\/ui(\/|$)|@\/|\.)/;
-
-export const noBareButtonLabel = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A button says its result as a verb and a noun, never a bare Submit, OK or Confirm.",
-    },
-    schema: [],
-    messages: {
-      "bare-label":
-        'A button says its result: "Create customer", "Save changes", "Remove mailbox". "{{label}}" says nothing about what happens.',
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-
-    function report(node, label) {
-      context.report({ node, messageId: "bare-label", data: { label } });
-    }
-
-    return {
-      JSXElement(node) {
-        const imported = importOf(node.openingElement.name);
-        if (!imported || !BUTTONS.has(imported.name) || !FROM_DESIGN_SYSTEM.test(imported.source)) {
-          return;
-        }
-        const label = childText(node);
-        if (label !== null && BARE.test(label)) report(node.openingElement, label);
-      },
-      JSXAttribute(node) {
-        if (node.name.name !== "submit" || node.value?.type !== "JSXExpressionContainer") return;
-        const { expression } = node.value;
-        if (expression.type !== "ObjectExpression") return;
-        for (const property of expression.properties) {
-          if (keyName(property) !== "label") continue;
-          const label = literalText(property.value);
-          if (label !== null && BARE.test(label.trim())) report(property.value, label.trim());
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-choice-control-wrapper.js

@@ -1,97 +0,0 @@
-const CHOICE_CONTROLS = new Set(["Select", "ToggleGroup", "RadioGroup", "Tabs"]);
-
-const FUNCTIONS = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
-
-function enclosingFunction(node) {
-  let current = node.parent;
-  while (current && !FUNCTIONS.has(current.type)) current = current.parent;
-  return current;
-}
-
-/** A component's own props: a destructured or typed parameter. */
-const isComponent = (fn) =>
-  fn.params.some((param) => param.type === "ObjectPattern" || param.typeAnnotation);
-
-/** Whether `owner` handed the element its value: the element's own component, or a callback inside it. */
-function handedTo(element, owner) {
-  for (let fn = enclosingFunction(element); fn; fn = enclosingFunction(fn)) {
-    if (fn === owner) return true;
-    if (isComponent(fn)) return false;
-  }
-  return false;
-}
-
-/** The identifiers in a handler that invoke what they name: the handler itself, a callee, or a method's receiver. */
-function invoked(handler) {
-  const found = [];
-  const visit = (node) => {
-    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- walks the generic AST, where only an object whose type is a string is a node.
-    if (!node || typeof node.type !== "string") return;
-    if (node.type === "Identifier") {
-      const parent = node.parent;
-      const isCallee = parent?.type === "CallExpression" && parent.callee === node;
-      const isReceiver =
-        parent?.type === "MemberExpression" &&
-        parent.object === node &&
-        parent.parent?.type === "CallExpression" &&
-        parent.parent.callee === parent;
-      if (node === handler || isCallee || isReceiver) found.push(node);
-    }
-    for (const [key, value] of Object.entries(node)) {
-      if (key === "parent") continue;
-      for (const child of Array.isArray(value) ? value : [value]) {
-        // oxlint-disable-next-line anti-slop/no-runtime-typeof -- walks the generic AST, where only an object whose type is a string is a node.
-        if (child && typeof child.type === "string") visit(child);
-      }
-    }
-  };
-  visit(handler);
-  return found;
-}
-
-/**
- * A kit choice control whose onValueChange forwards to a callback the enclosing
- * component was handed. `ToolbarToggle` flattened Base UI's array into a string
- * there, and "Split by" stopped working while every check stayed green.
- */
-export const noChoiceControlWrapper = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Render a kit choice control where its value is used, never behind a wrapper that forwards it.",
-    },
-    schema: [],
-    messages: {
-      wrapper:
-        "Render the kit's {{control}} where the value is used, with its own API: this one forwards onValueChange to \"{{name}}\", which the component was handed, and a wrapper is where the value's shape gets lost.",
-    },
-  },
-  create(context) {
-    return {
-      "JSXAttribute[name.name='onValueChange'] > JSXExpressionContainer"(container) {
-        const opening = container.parent.parent;
-        const control = opening.name.type === "JSXIdentifier" ? opening.name.name : null;
-        if (!CHOICE_CONTROLS.has(control)) return;
-        const handler = container.expression;
-        for (const identifier of invoked(handler)) {
-          const scope = context.sourceCode.getScope(identifier);
-          let variable = null;
-          for (let current = scope; current && !variable; current = current.upper) {
-            variable = current.set.get(identifier.name) ?? null;
-          }
-          const definition = variable?.defs[0];
-          if (definition?.type !== "Parameter") continue;
-          if (definition.node === handler) continue;
-          if (!handedTo(opening, definition.node)) continue;
-          context.report({
-            node: container,
-            messageId: "wrapper",
-            data: { control, name: identifier.name },
-          });
-          return;
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-comment.js

@@ -1,77 +0,0 @@
-/*
- * Code says what it does in its names and its structure, and a test says what
- * it proves in its name and its assertions; a comment restates one of them and
- * nothing keeps it true when the code changes. A directive to a tool is not
- * prose for the reader: ESLint's, Oxlint's, TypeScript's, Biome's, Prettier's,
- * coverage's and Vitest's stay, and so does the marker the seam guard requires.
- */
-
-const DIRECTIVE =
-  /^[*/]?\s*(?:@ts-|eslint-|eslint\s+[\w@/-]+\s*:|oxlint-|biome-ignore|<reference\b|istanbul\b|c8\s|prettier-ignore|@vitest-environment|@jsx)/;
-
-const SEAM_MARKER = /^\s*NADIA\((?:added|changed|removed)\):/;
-
-function moduleHeader(comments, firstTokenStart) {
-  const [first, ...rest] = comments;
-  if (first === undefined || first.range[1] > firstTokenStart) return [];
-  if (first.type === "Block") return [first];
-  const run = [first];
-  for (const next of rest) {
-    if (
-      next.type !== "Line" ||
-      next.range[1] > firstTokenStart ||
-      next.loc.start.line !== run.at(-1).loc.end.line + 1
-    ) {
-      break;
-    }
-    run.push(next);
-  }
-  return run;
-}
-
-export const noComment = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Disallow comments in code, but for directives to a tool, the marker the seam guard requires and, when allowed, the one comment that opens a module",
-    },
-    schema: [
-      {
-        type: "object",
-        properties: { allowModuleHeader: { type: "boolean" } },
-        additionalProperties: false,
-      },
-    ],
-    defaultOptions: [{ allowModuleHeader: false }],
-    messages: {
-      comment:
-        "Code says what it does in its names and its structure, never in a comment. Rename or restructure, or remove the comment.",
-    },
-  },
-
-  create(context) {
-    const [{ allowModuleHeader }] = context.options;
-    const { sourceCode } = context;
-    return {
-      Program() {
-        const prose = sourceCode
-          .getAllComments()
-          .filter(
-            (comment) =>
-              comment.type !== "Shebang" &&
-              !DIRECTIVE.test(comment.value) &&
-              !SEAM_MARKER.test(comment.value),
-          );
-        const header = allowModuleHeader
-          ? moduleHeader(prose, sourceCode.ast.tokens[0]?.range[0] ?? Infinity)
-          : [];
-        for (const comment of prose) {
-          if (!header.includes(comment)) {
-            context.report({ loc: comment.loc, messageId: "comment" });
-          }
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-control-in-read-only-surface.js

@@ -1,106 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match a
- * `Button` below `TooltipContent`, but not follow a renamed import to the part,
- * count the links across a HoverCardContent's children and its summary's
- * `action`.
- */
-import { renderedImports, walk } from "./rendered-import.js";
-
-const OVERLAYS = new Set(["Tooltip", "HoverCard"]);
-const CONTROLS = new Set(["Button", "ButtonLink", "TextLink", "Link", "a"]);
-const NATIVE_CONTROLS = new Set(["input", "select", "textarea"]);
-const HOVER_CARD_SUMMARY = "HoverCardSummary";
-
-const hasAttribute = (openingElement, attributeName) =>
-  openingElement.attributes.some(
-    (attribute) => attribute.type === "JSXAttribute" && attribute.name.name === attributeName,
-  );
-
-export const noControlInReadOnlySurface = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Tooltip text and a Choicebox tile are for reading; a HoverCard holds at most one link.",
-    },
-    schema: [],
-    messages: {
-      "read-only-surface":
-        "Tooltip text and a Choicebox tile are for reading: move the control outside. A HoverCard holds at most one link, through HoverCardSummary's `action`, and never a second Tooltip or HoverCard; for more, open a Popover, a menu or the record's page.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const { visitorKeys } = context.sourceCode;
-
-    const nameOf = (element) => {
-      const { name } = element.openingElement;
-      if (name.type !== "JSXIdentifier" && name.type !== "JSXMemberExpression") return null;
-      if (name.type === "JSXIdentifier" && /^[a-z]/.test(name.name)) return name.name;
-      const imported = importOf(name);
-      if (!imported) return null;
-      return imported.name === "default" ? name.name : imported.name;
-    };
-
-    const isInteractive = (element, name) =>
-      CONTROLS.has(name) ||
-      NATIVE_CONTROLS.has(name) ||
-      hasAttribute(element.openingElement, "onClick") ||
-      hasAttribute(element.openingElement, "tabIndex");
-
-    function visitChildren(container, visit) {
-      for (const child of container.children) {
-        if (visit(child) === false) continue;
-        walk(child, visitorKeys, visit);
-      }
-    }
-
-    function checkTooltipContent(container) {
-      visitChildren(container, (child) => {
-        if (child.type !== "JSXElement") return true;
-        const name = nameOf(child);
-        if (!OVERLAYS.has(name) && !isInteractive(child, name)) return true;
-        context.report({ node: child.openingElement, messageId: "read-only-surface" });
-        return false;
-      });
-    }
-
-    function checkChoiceboxItem(container) {
-      visitChildren(container, (child) => {
-        if (child.type !== "JSXElement" || !isInteractive(child, nameOf(child))) return true;
-        context.report({ node: child.openingElement, messageId: "read-only-surface" });
-        return false;
-      });
-    }
-
-    function checkHoverCardContent(container) {
-      let links = 0;
-      visitChildren(container, (child) => {
-        if (child.type !== "JSXElement") return true;
-        const name = nameOf(child);
-        const { openingElement } = child;
-        if (OVERLAYS.has(name)) {
-          context.report({ node: openingElement, messageId: "read-only-surface" });
-          return false;
-        }
-        const isLink =
-          CONTROLS.has(name) ||
-          hasAttribute(openingElement, "onClick") ||
-          (name === HOVER_CARD_SUMMARY && hasAttribute(openingElement, "action"));
-        if (!isLink) return true;
-        links += 1;
-        if (links > 1) context.report({ node: openingElement, messageId: "read-only-surface" });
-        return true;
-      });
-    }
-
-    return {
-      JSXElement(node) {
-        const name = nameOf(node);
-        if (name === "TooltipContent") checkTooltipContent(node);
-        else if (name === "ChoiceboxGroupItem") checkChoiceboxItem(node);
-        else if (name === "HoverCardContent") checkHoverCardContent(node);
-      },
-    };
-  },
-};