@nadicodeai/ui 12.1.165 → 12.1.166

package/dist/eslint/rules/settings-limit-in-footer.js

@@ -1,94 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can find a
- * `maxLength` inside a `SettingsSection`, but not follow a renamed import to the
- * component, nor read whether the section's `save` or `apply` object names a hint.
- */
-import { packageModules, partOf, renderedImports } from "./rendered-import.js";
-
-const SECTION = new Map([
-  [
-    "SettingsSection",
-    packageModules("settings-section").map((from) => ({ from, part: "SettingsSection" })),
-  ],
-]);
-
-const attributeNamed = (openingElement, name) =>
-  openingElement.attributes.find(
-    (attribute) => attribute.type === "JSXAttribute" && attribute.name.name === name,
-  );
-
-/** true: the section shows a footer line; false: it shows none; null: the source does not say. */
-function footerLine(openingElement) {
-  if (openingElement.attributes.some((attribute) => attribute.type === "JSXSpreadAttribute"))
-    return null;
-  if (
-    attributeNamed(openingElement, "footerHint") ||
-    attributeNamed(openingElement, "lockedReason")
-  )
-    return true;
-  const commit = attributeNamed(openingElement, "save") ?? attributeNamed(openingElement, "apply");
-  if (!commit) return false;
-  const value = commit.value?.type === "JSXExpressionContainer" ? commit.value.expression : null;
-  if (value?.type !== "ObjectExpression") return null;
-  if (value.properties.some((property) => property.type === "SpreadElement")) return null;
-  return value.properties.some(
-    (property) =>
-      property.type === "Property" && (property.key.name ?? property.key.value) === "hint",
-  );
-}
-
-function limitsIn(element, isSection) {
-  const found = [];
-  const visit = (node) => {
-    if (node.type === "JSXElement") {
-      if (node !== element && isSection(node.openingElement)) return;
-      const limit = attributeNamed(node.openingElement, "maxLength");
-      if (limit) found.push(limit);
-      node.children.forEach(visit);
-    } else if (node.type === "JSXFragment") {
-      node.children.forEach(visit);
-    } else if (node.type === "JSXExpressionContainer") {
-      visitExpression(node.expression);
-    }
-  };
-  const visitExpression = (expression) => {
-    if (!expression) return;
-    if (expression.type === "JSXElement" || expression.type === "JSXFragment") visit(expression);
-    else if (expression.type === "LogicalExpression") visitExpression(expression.right);
-    else if (expression.type === "ConditionalExpression") {
-      visitExpression(expression.consequent);
-      visitExpression(expression.alternate);
-    }
-  };
-  element.children.forEach(visit);
-  return found;
-}
-
-export const settingsLimitInFooter = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A SettingsSection whose field takes a maxLength says the limit in its footer line, as Vercel's settings cards do.",
-    },
-    schema: [],
-    messages: {
-      "limit-not-said":
-        "Say this limit in the card's footer line (`save.hint`, `apply.hint` or `footerHint`), worded by the product's catalogue, such as \"Please use 48 characters at maximum.\"",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const isSection = (openingElement) =>
-      partOf(importOf(openingElement.name), SECTION, context.filename) === "SettingsSection";
-
-    return {
-      JSXElement(node) {
-        if (!isSection(node.openingElement)) return;
-        if (footerLine(node.openingElement) !== false) return;
-        for (const limit of limitsIn(node, isSection))
-          context.report({ node: limit, messageId: "limit-not-said" });
-      },
-    };
-  },
-};

package/dist/eslint/rules/skeleton-in-region.js

@@ -1,80 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-syntax` selects a JSX element by
- * name and ancestors, but not the one the import renders under another name,
- * nor "this file or this function is a loading view", which depends on the
- * file name and the enclosing function's name together.
- */
-import { renderedImports } from "./rendered-import.js";
-
-const SKELETON = "Skeleton";
-const REGION = "SkeletonRegion";
-const PLACEHOLDER_FILE = /(?:^|\/)(?:loading|[^/]+-skeleton)\.[jt]sx$/;
-const PLACEHOLDER_FUNCTION = /Skeleton$/;
-const FUNCTIONS = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
-
-const hasContent = (child) => {
-  if (child.type === "JSXText") return child.value.trim() !== "";
-  if (child.type === "JSXExpressionContainer")
-    return child.expression.type !== "JSXEmptyExpression";
-  return true;
-};
-
-const marksBusy = (openingElement) =>
-  openingElement.attributes.some(
-    (attribute) => attribute.type === "JSXAttribute" && attribute.name.name === "aria-busy",
-  );
-
-function functionName(fn) {
-  if (fn.id) return fn.id.name;
-  const owner = fn.parent;
-  return owner.type === "VariableDeclarator" && owner.id.type === "Identifier"
-    ? owner.id.name
-    : null;
-}
-
-export const skeletonInRegion = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Placeholders of a loading view sit in a SkeletonRegion, or under an element marked aria-busy.",
-    },
-    schema: [],
-    messages: {
-      "placeholder-outside-region":
-        "Wrap these placeholders in <SkeletonRegion busy> from @nadicodeai/ui/components/skeleton so the loading view is aria-busy; a component that renders both the placeholders and the data passes busy={isPending}.",
-    },
-  },
-  create(context) {
-    const filename = context.filename.replaceAll("\\", "/");
-    const loadingFile = PLACEHOLDER_FILE.test(filename);
-    const importOf = renderedImports(context);
-
-    function loadingView(element) {
-      if (loadingFile) return true;
-      for (let current = element.parent; current; current = current.parent) {
-        if (!FUNCTIONS.has(current.type)) continue;
-        if (PLACEHOLDER_FUNCTION.test(functionName(current) ?? "")) return true;
-      }
-      return false;
-    }
-
-    function inABusyRegion(element) {
-      for (let current = element.parent; current; current = current.parent) {
-        if (current.type !== "JSXElement") continue;
-        if (importOf(current.openingElement.name)?.name === REGION) return true;
-        if (marksBusy(current.openingElement)) return true;
-      }
-      return false;
-    }
-
-    return {
-      JSXElement(node) {
-        if (importOf(node.openingElement.name)?.name !== SKELETON) return;
-        if (node.children.some(hasContent)) return;
-        if (!loadingView(node) || inABusyRegion(node)) return;
-        context.report({ node: node.openingElement, messageId: "placeholder-outside-region" });
-      },
-    };
-  },
-};

package/dist/eslint/rules/sortable-heading-uses-sort.js

@@ -1,79 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector cannot follow
- * a renamed `TableHead` or `Button` import, nor tell a column definition's
- * `header` from any other property of that name.
- */
-import { packageModules, partOf, renderedImports, walk } from "./rendered-import.js";
-
-const exporters = (module, part) =>
-  new Map([
-    [part, [...packageModules(module), `@/components/${module}`].map((from) => ({ from, part }))],
-  ]);
-
-const TABLE_HEAD = exporters("table", "TableHead");
-const BUTTON = exporters("button", "Button");
-
-const FUNCTIONS = new Set(["FunctionExpression", "ArrowFunctionExpression"]);
-const COLUMN_KEYS = new Set(["accessorKey", "accessorFn", "id", "cell"]);
-
-const keyName = (property) => {
-  if (property.computed) return null;
-  return property.key.name ?? property.key.value ?? null;
-};
-
-const isColumnHeader = (property) =>
-  property.type === "Property" &&
-  keyName(property) === "header" &&
-  FUNCTIONS.has(property.value.type) &&
-  property.parent.properties.some(
-    (sibling) => sibling.type === "Property" && COLUMN_KEYS.has(keyName(sibling)),
-  );
-
-export const sortableHeadingUsesSort = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "A sortable heading is TableHead's sort prop, not a button drawn inside it.",
-    },
-    schema: [],
-    messages: {
-      "drawn-sort-button":
-        "A sortable heading is TableHead's sort prop (order, next, onSort), not a button you draw. The sort prop gives the heading aria-sort and names the next sort.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const { visitorKeys } = context.sourceCode;
-
-    const drawsAControl = (opening) =>
-      opening.attributes.some(
-        (attribute) => attribute.type === "JSXAttribute" && attribute.name.name === "onClick",
-      ) || partOf(importOf(opening.name), BUTTON, context.filename) === "Button";
-
-    const reported = new Set();
-
-    function reportControlsBelow(root, skipped) {
-      walk(root, visitorKeys, (child) => {
-        if (child === skipped) return false;
-        if (child.type === "JSXOpeningElement" && !reported.has(child) && drawsAControl(child)) {
-          reported.add(child);
-          context.report({ node: child, messageId: "drawn-sort-button" });
-        }
-        return true;
-      });
-    }
-
-    return {
-      JSXElement(node) {
-        const { openingElement } = node;
-        if (partOf(importOf(openingElement.name), TABLE_HEAD, context.filename) !== "TableHead") {
-          return;
-        }
-        reportControlsBelow(node, openingElement);
-      },
-      Property(node) {
-        if (isColumnHeader(node)) reportControlsBelow(node.value, null);
-      },
-    };
-  },
-};

package/dist/eslint/rules/table-cell-inset-owner.js

@@ -1,107 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match a
- * padding class written as a literal on `<TableCell>`, but not one composed
- * through `cn(...)` or a conditional, not which JSX name is the table's part
- * once the import is renamed, and not which object literal is a column
- * definition rather than any other object with a `className`.
- */
-import { PACKAGE_BARREL, partOf, renderedImports, walk } from "./rendered-import.js";
-
-const CELL_PARTS = new Set(["TableHead", "TableCell"]);
-
-const TABLE_PARTS = new Map(
-  [...CELL_PARTS].map((name) => [
-    name,
-    ["@nadicodeai/ui/components/table", PACKAGE_BARREL, "@/components/table"].map((from) => ({
-      from,
-      part: name,
-    })),
-  ]),
-);
-
-const COLUMN_KEYS = new Set(["accessorKey", "accessorFn", "header", "cell"]);
-const SIDEWAYS_PADDING = /^-?(?:px|ps|pe|pl|pr)-(?<step>.+?)!?$/;
-
-const keyName = (property) => {
-  if (property.computed) return null;
-  return property.key.type === "Identifier" ? property.key.name : property.key.value;
-};
-
-const propertyNamed = (objectExpression, name) =>
-  objectExpression.properties.find(
-    (property) => property.type === "Property" && keyName(property) === name,
-  );
-
-function withoutVariants(utility) {
-  let depth = 0;
-  let start = 0;
-  for (let index = 0; index < utility.length; index += 1) {
-    const character = utility[index];
-    if (character === "[") depth += 1;
-    else if (character === "]") depth -= 1;
-    else if (character === ":" && depth === 0) start = index + 1;
-  }
-  return utility.slice(start).replace(/^!/, "");
-}
-
-const insetsSideways = (utility) => {
-  const step = SIDEWAYS_PADDING.exec(withoutVariants(utility))?.groups.step;
-  return step !== undefined && step !== "0";
-};
-
-export const tableCellInsetOwner = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "The table insets its cells sideways; a cell or a column never sets it.",
-    },
-    schema: [],
-    messages: {
-      "cell-inset":
-        "Table cells are inset 8 px sideways at every width by the table. Remove the class; set the width with the column's `size`.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const { visitorKeys } = context.sourceCode;
-
-    function checkClasses(value) {
-      const fragments = [];
-      const read = (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 (node.type === "Literal" && typeof node.value === "string") fragments.push(node.value);
-        if (node.type === "TemplateElement") fragments.push(node.value.cooked ?? node.value.raw);
-      };
-      read(value);
-      walk(value, visitorKeys, read);
-      const refused = fragments
-        .flatMap((fragment) => fragment.split(/\s+/).filter(Boolean))
-        .some(insetsSideways);
-      if (refused) context.report({ node: value, messageId: "cell-inset" });
-    }
-
-    return {
-      JSXOpeningElement(node) {
-        if (!CELL_PARTS.has(partOf(importOf(node.name), TABLE_PARTS, context.filename) ?? "")) {
-          return;
-        }
-        for (const attribute of node.attributes) {
-          if (attribute.type === "JSXAttribute" && attribute.name.name === "className") {
-            if (attribute.value) checkClasses(attribute.value);
-          }
-        }
-      },
-      ObjectExpression(node) {
-        const isColumn = node.properties.some(
-          (property) => property.type === "Property" && COLUMN_KEYS.has(keyName(property)),
-        );
-        if (!isColumn) return;
-        const own = propertyNamed(node, "className");
-        if (own) checkClasses(own.value);
-        const meta = propertyNamed(node, "meta")?.value;
-        const metaOwn = meta?.type === "ObjectExpression" && propertyNamed(meta, "className");
-        if (metaOwn) checkClasses(metaOwn.value);
-      },
-    };
-  },
-};

package/dist/eslint/rules/tabs-selection-is-controlled.js

@@ -1,47 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match a
- * `JSXAttribute[name.name='defaultValue']`, but not that the element is the
- * package's Tabs rather than TabsNav or a local component, nor that a missing
- * `value` is covered by a spread. Those need the import binding and the
- * attribute list read together.
- */
-import { packageModules, partOf, renderedImports } from "./rendered-import.js";
-
-const TABS = new Map([["Tabs", packageModules("tabs").map((from) => ({ from, part: "Tabs" }))]]);
-
-const hasAttribute = (openingElement, attributeName) =>
-  openingElement.attributes.some(
-    (attribute) => attribute.type === "JSXAttribute" && attribute.name.name === attributeName,
-  );
-
-const hasSpread = (openingElement) =>
-  openingElement.attributes.some((attribute) => attribute.type === "JSXSpreadAttribute");
-
-export const tabsSelectionIsControlled = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Tabs is controlled by a `value` read from the address, never `defaultValue`.",
-    },
-    schema: [],
-    messages: {
-      "chosen-tab-in-address":
-        "The chosen tab lives in the address: control Tabs with `value` read from the route or ?tab=, so a reload, Back and a shared link restore it.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    return {
-      JSXElement(node) {
-        const { openingElement } = node;
-        if (!partOf(importOf(openingElement.name), TABS, context.filename)) return;
-        const uncontrolled =
-          hasAttribute(openingElement, "defaultValue") ||
-          (!hasAttribute(openingElement, "value") && !hasSpread(openingElement));
-        if (uncontrolled) {
-          context.report({ node: openingElement, messageId: "chosen-tab-in-address" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/test-files-from-one-definition.js

@@ -1,67 +0,0 @@
-const EVERY_TEST =
-  /(?:^|\/)\*\.test(?:-\*)?\.|(?:^|\/)tests\/\*\*(?:\/\*[^/]*)?$|(?:^|\/)\*\.e2e\.ts$/;
-
-const textOf = (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 (node.type === "Literal" && typeof node.value === "string") return node.value;
-  if (node.type === "TemplateLiteral")
-    return node.quasis.map((quasi) => quasi.value.cooked).join("*");
-  return null;
-};
-
-const variableNamed = (scope, name) => {
-  for (let current = scope; current; current = current.upper) {
-    const variable = current.set.get(name);
-    if (variable) return variable;
-  }
-  return undefined;
-};
-
-const keyName = (property) =>
-  property.key.type === "Identifier" ? property.key.name : textOf(property.key);
-
-export const testFilesFromOneDefinition = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A config block skips tests with TEST_FILES from @nadicodeai/test-support/test-files, never a glob of its own.",
-    },
-    schema: [],
-    messages: {
-      handWritten:
-        "Skip tests with TEST_FILES from @nadicodeai/test-support/test-files: a test glob written here misses the next kind of test.",
-    },
-  },
-  create(context) {
-    const constantOf = (node) => {
-      if (node.type !== "Identifier") return null;
-      const definition = variableNamed(context.sourceCode.getScope(node), node.name)?.defs[0];
-      return definition?.type === "Variable" ? definition.node.init : null;
-    };
-    const checkGlobs = (node) => {
-      if (node.type === "Identifier") {
-        const init = constantOf(node);
-        if (init?.type === "ArrayExpression") checkGlobs(init);
-        return;
-      }
-      if (node.type !== "ArrayExpression") return;
-      for (const element of node.elements) {
-        if (!element) continue;
-        if (element.type === "SpreadElement") {
-          checkGlobs(element.argument);
-          continue;
-        }
-        const glob = textOf(constantOf(element) ?? element);
-        if (glob !== null && EVERY_TEST.test(glob)) {
-          context.report({ node: element, messageId: "handWritten" });
-        }
-      }
-    };
-    return {
-      Property(node) {
-        if (keyName(node) === "ignores") checkGlobs(node.value);
-      },
-    };
-  },
-};

package/dist/eslint/rules/tooltip-only-arrow.js

@@ -1,38 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match a
- * member element named `Arrow`, but not that its object is an import from
- * `@base-ui/react`, so it would also refuse a product's own `Chart.Arrow`.
- */
-const BASE_UI = /^@base-ui\/react(\/|$)/;
-
-const rootOf = (name) => (name.type === "JSXMemberExpression" ? rootOf(name.object) : name);
-
-export const tooltipOnlyArrow = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Only a tooltip has a pointer: a popup part named Arrow belongs in tooltip.tsx.",
-    },
-    schema: [],
-    messages: {
-      "popup-arrow": "Only a tooltip has a pointer. Remove the arrow from this popup.",
-    },
-  },
-  create(context) {
-    const baseUiBindings = new Set();
-    return {
-      ImportDeclaration(node) {
-        if (node.importKind === "type" || !BASE_UI.test(node.source.value)) return;
-        for (const specifier of node.specifiers) {
-          if (specifier.importKind !== "type") baseUiBindings.add(specifier.local.name);
-        }
-      },
-      JSXOpeningElement(node) {
-        const { name } = node;
-        if (name.type !== "JSXMemberExpression" || name.property.name !== "Arrow") return;
-        if (baseUiBindings.has(rootOf(name).name))
-          context.report({ node, messageId: "popup-arrow" });
-      },
-    };
-  },
-};

package/dist/eslint/rules/tooltip-trigger-accessible-name.js

@@ -1,114 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match a
- * `TooltipTrigger` with no `aria-label`, but not that the package's trigger is
- * meant rather than a local one, that its children draw no text, nor that the
- * name may sit on the element passed as `render`. Those need the import
- * binding, the children and the `render` element read together.
- */
-import { PACKAGE_BARREL, partOf, renderedImports, staticAttribute } from "./rendered-import.js";
-
-const TRIGGERS = new Map(
-  [
-    ["TooltipTrigger", "tooltip"],
-    ["PopoverTrigger", "popover"],
-    ["HoverCardTrigger", "hover-card"],
-  ].map(([name, module]) => [
-    name,
-    [`@nadicodeai/ui/components/${module}`, PACKAGE_BARREL, `@/components/${module}`].map(
-      (from) => ({ from, part: name }),
-    ),
-  ]),
-);
-
-const BUTTONS = new Map(
-  ["Button", "ButtonLink"].map((name) => [
-    name,
-    ["@nadicodeai/ui/components/button", PACKAGE_BARREL].map((from) => ({ from, part: name })),
-  ]),
-);
-
-const NAMING_ATTRIBUTES = new Set(["aria-label", "aria-labelledby"]);
-
-const hasAttribute = (openingElement, names) =>
-  openingElement.attributes.some(
-    (attribute) => attribute.type === "JSXAttribute" && names.has(attribute.name.name),
-  );
-
-const hasSpread = (openingElement) =>
-  openingElement.attributes.some((attribute) => attribute.type === "JSXSpreadAttribute");
-
-function staticText(expression) {
-  if (expression.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.
-    return typeof expression.value === "string" ? expression.value : null;
-  }
-  if (expression.type === "TemplateLiteral" && expression.expressions.length === 0) {
-    return expression.quasis[0].value.cooked;
-  }
-  return null;
-}
-
-function rendersText(child) {
-  if (child.type === "JSXText") return child.value.trim() !== "";
-  if (child.type === "JSXElement" || child.type === "JSXFragment") {
-    return child.children.some(rendersText);
-  }
-  if (child.type !== "JSXExpressionContainer") return false;
-  const { expression } = child;
-  if (expression.type === "JSXEmptyExpression") return false;
-  const text = staticText(expression);
-  if (text !== null) return text.trim() !== "";
-  return expression.type !== "Literal";
-}
-
-const isElement = (child) => child.type === "JSXElement" || child.type === "JSXFragment";
-
-const isIconOnly = (children) => children.some(isElement) && !children.some(rendersText);
-
-const renderElement = (openingElement) => {
-  const attribute = openingElement.attributes.find(
-    (candidate) => candidate.type === "JSXAttribute" && candidate.name.name === "render",
-  );
-  const expression = attribute?.value?.expression;
-  return expression?.type === "JSXElement" ? expression : null;
-};
-
-const isIconButton = (importOf, filename, element) =>
-  Boolean(partOf(importOf(element.openingElement.name), BUTTONS, filename)) &&
-  String(staticAttribute(element.openingElement, "size") ?? "").startsWith("icon");
-
-export const tooltipTriggerAccessibleName = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A trigger whose children are only icons is named by an aria-label: the tooltip describes the control, it does not name it.",
-    },
-    schema: [],
-    messages: {
-      "icon-only-trigger":
-        "An icon-only trigger needs an aria-label that names the action. The tooltip describes the control; it does not name it.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    return {
-      JSXElement(node) {
-        const { openingElement } = node;
-        if (!partOf(importOf(openingElement.name), TRIGGERS, context.filename)) return;
-        if (hasSpread(openingElement) || hasAttribute(openingElement, NAMING_ATTRIBUTES)) return;
-        const rendered = renderElement(openingElement);
-        if (rendered) {
-          if (isIconButton(importOf, context.filename, rendered)) return;
-          if (hasSpread(rendered.openingElement)) return;
-          if (hasAttribute(rendered.openingElement, NAMING_ATTRIBUTES)) return;
-        }
-        const drawsItself = node.children.some(isElement) || node.children.some(rendersText);
-        const children = drawsItself ? node.children : (rendered?.children ?? []);
-        if (isIconOnly(children)) {
-          context.report({ node: openingElement, messageId: "icon-only-trigger" });
-        }
-      },
-    };
-  },
-};