@nadicodeai/ui 12.1.95 → 12.1.97

package/dist/eslint/index.js

@@ -3,15 +3,19 @@ import { readdirSync, readFileSync } from "node:fs";
 
 import { builtinRules } from "eslint/use-at-your-own-risk";
 
+import { emptyStateOwner } from "./rules/empty-state-owner.js";
+import { menuOwner } from "./rules/menu-owner.js";
 import { noAppFeatureComponent } from "./rules/no-app-feature-component.js";
 import { noChoiceControlWrapper } from "./rules/no-choice-control-wrapper.js";
 import { noComment } from "./rules/no-comment.js";
+import { noDecorativeIcon } from "./rules/no-decorative-icon.js";
 import { noDeprecatedZodApi } from "./rules/no-deprecated-zod-api.js";
 import { noGlobalPatch } from "./rules/no-global-patch.js";
 import { noPackageComponentRedefinition } from "./rules/no-package-component-redefinition.js";
 import { noShadcnAppearanceOverride } from "./rules/no-shadcn-appearance-override.js";
 import { noSubjectDerivedExpectation } from "./rules/no-subject-derived-expectation.js";
 import { noWriteInSubscription } from "./rules/no-write-in-subscription.js";
+import { pageComposition } from "./rules/page-composition.js";
 import { serverActionDiscipline } from "./rules/server-action-discipline.js";
 import { strictDesignSystemSelectors } from "./strict-design-system.js";
 
@@ -35,6 +39,7 @@ function readPublishedVersion() {
     } catch {
       continue;
     }
+    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- parses package.json at its boundary; this package has no schema library.
     if (manifest?.name === PUBLISHING_PACKAGE && typeof manifest.version === "string") {
       return manifest.version;
     }
@@ -101,15 +106,19 @@ const plugin = {
   configs: {},
   rules: {
     ...strictSelectorRules,
+    "empty-state-owner": emptyStateOwner,
+    "menu-owner": menuOwner,
     "no-app-feature-component": noAppFeatureComponent,
     "no-choice-control-wrapper": noChoiceControlWrapper,
     "no-comment": noComment,
+    "no-decorative-icon": noDecorativeIcon,
     "no-deprecated-zod-api": noDeprecatedZodApi,
     "no-global-patch": noGlobalPatch,
     "no-package-component-redefinition": noPackageComponentRedefinition,
     "no-shadcn-appearance-override": noShadcnAppearanceOverride,
     "no-subject-derived-expectation": noSubjectDerivedExpectation,
     "no-write-in-subscription": noWriteInSubscription,
+    "page-composition": pageComposition,
     "server-action-discipline": serverActionDiscipline,
   },
 };

package/dist/eslint/rules/empty-state-owner.js

@@ -0,0 +1,145 @@
+/*
+ * Standard tool checked first: a `no-restricted-syntax` selector can match
+ * `items.length === 0 ? <X/> : …`, but not which branch is the empty one once
+ * the test is turned around (`items.length > 0 ? <List/> : <p/>`, an early
+ * `if` whose empty branch is the next `return`), so it would either miss those
+ * or report the list branch.
+ */
+import { renderedImports } from "./rendered-import.js";
+
+const OWNERS = [
+  "EmptyState",
+  "CollectionPage",
+  "RecordList",
+  "ActivityFeed",
+  "LibraryShelf",
+  "CatalogDrawer",
+  "DataTable",
+  "CommandEmpty",
+  "ComboboxEmpty",
+];
+
+const SIZE_PROPERTIES = new Set(["length", "size"]);
+const COUNT = /^count$|[a-z0-9]Count$/;
+
+const unwrapChain = (node) => (node.type === "ChainExpression" ? node.expression : node);
+
+const isSize = (node) => {
+  const read = unwrapChain(node);
+  if (read.type === "Identifier") return COUNT.test(read.name);
+  if (read.type !== "MemberExpression" || read.computed) return false;
+  return SIZE_PROPERTIES.has(read.property.name) || COUNT.test(read.property.name);
+};
+
+const MIRRORED = { "<": ">", ">": "<", "<=": ">=", ">=": "<=" };
+
+const EMPTY_WHEN = {
+  "===": { 0: "empty" },
+  "==": { 0: "empty" },
+  "!==": { 0: "present" },
+  "!=": { 0: "present" },
+  "<": { 1: "empty" },
+  "<=": { 0: "empty" },
+  ">": { 0: "present" },
+  ">=": { 1: "present" },
+};
+
+function emptiness(test) {
+  const node = unwrapChain(test);
+  if (isSize(node)) return "present";
+  if (node.type === "UnaryExpression" && node.operator === "!") {
+    const inner = emptiness(node.argument);
+    if (inner === "empty") return "present";
+    if (inner === "present") return "empty";
+    return null;
+  }
+  if (node.type === "LogicalExpression") {
+    const sides = [emptiness(node.left), emptiness(node.right)];
+    if (node.operator === "&&" && sides.includes("empty")) return "empty";
+    if (node.operator === "||" && sides.includes("present")) return "present";
+    return null;
+  }
+  if (node.type !== "BinaryExpression") return null;
+  let { operator, left, right } = 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 number.
+  if (isSize(right) && typeof left.value === "number") {
+    [left, right] = [right, left];
+    operator = MIRRORED[operator] ?? operator;
+  }
+  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- ESTree types Literal.value as string | number | boolean | RegExp | bigint | null; only typeof picks the number.
+  if (!isSize(left) || typeof right.value !== "number") return null;
+  return EMPTY_WHEN[operator]?.[right.value] ?? null;
+}
+
+function returned(statement) {
+  if (!statement) return null;
+  if (statement.type === "ReturnStatement") return statement.argument;
+  if (statement.type === "BlockStatement") {
+    const found = statement.body.find((inner) => inner.type === "ReturnStatement");
+    return found?.argument ?? null;
+  }
+  return null;
+}
+
+function nextStatement(statement) {
+  const body = statement.parent.body;
+  if (!Array.isArray(body)) return null;
+  return body[body.indexOf(statement) + 1] ?? null;
+}
+
+export const emptyStateOwner = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "An absence renders EmptyState, or a composition that draws its own.",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          owners: { type: "array", items: { type: "string" }, uniqueItems: true },
+        },
+        additionalProperties: false,
+      },
+    ],
+    defaultOptions: [{ owners: [] }],
+    messages: {
+      "absence-branch":
+        "An absence is EmptyState: firstUse with the section's picture, nothingYet, noResults with its clear, or failed with its retry.",
+    },
+  },
+  create(context) {
+    const owners = new Set([...OWNERS, ...context.options[0].owners]);
+    const importOf = renderedImports(context);
+    const drawnByAnOwner = (element) =>
+      owners.has(importOf(element.openingElement.name)?.name ?? "");
+
+    function checkEmptyBranch(branch) {
+      const drawsItsOwn =
+        branch?.type === "JSXFragment" ||
+        (branch?.type === "JSXElement" && !drawnByAnOwner(branch));
+      if (drawsItsOwn) context.report({ node: branch, messageId: "absence-branch" });
+    }
+
+    return {
+      ConditionalExpression(node) {
+        const verdict = emptiness(node.test);
+        if (verdict === "empty") checkEmptyBranch(node.consequent);
+        else if (verdict === "present") checkEmptyBranch(node.alternate);
+      },
+      LogicalExpression(node) {
+        if (node.operator === "&&" && emptiness(node.left) === "empty") {
+          checkEmptyBranch(node.right);
+        }
+      },
+      IfStatement(node) {
+        const verdict = emptiness(node.test);
+        if (verdict === "empty") {
+          checkEmptyBranch(returned(node.consequent));
+        } else if (verdict === "present" && returned(node.consequent)) {
+          checkEmptyBranch(returned(node.alternate ?? nextStatement(node)));
+        }
+      },
+    };
+  },
+};

package/dist/eslint/rules/jsx-class-utility.js

@@ -59,6 +59,7 @@ function objectStringValues(objectExpression) {
   const values = [];
   for (const property of objectExpression.properties) {
     if (property.type !== "Property") continue;
+    // 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 (property.value.type === "Literal" && typeof property.value.value === "string") {
       values.push(property.value.value);
     }
@@ -80,9 +81,11 @@ function resolvedFragments(identifier, context, { objectsOnly = false } = {}) {
 
 /** Every string literal and template chunk in the subtree, in source order. */
 function literalFragments(node, fragments, { skipPropertyKeys, context }) {
+  // 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 === "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.
     if (typeof node.value === "string") fragments.push(node.value);
     return;
   }
@@ -124,6 +127,7 @@ function literalFragments(node, fragments, { skipPropertyKeys, context }) {
     if (skipPropertyKeys && key === "key" && node.type === "Property" && !node.computed) continue;
     if (Array.isArray(value)) {
       for (const child of value) literalFragments(child, fragments, { skipPropertyKeys, context });
+      // 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.
     } else if (value && typeof value === "object") {
       literalFragments(value, fragments, { skipPropertyKeys, context });
     }
@@ -160,6 +164,7 @@ function spreadClassUtilities(attribute, context, includeSlots) {
     if (property.type !== "Property" || property.computed) continue;
     const name = property.key.type === "Identifier" ? property.key.name : property.key.value;
     if (!isClassProperty(name, includeSlots) && name !== "class") continue;
+    // 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 (property.value.type !== "Literal" || typeof property.value.value !== "string") continue;
     values.push(...property.value.value.split(/\s+/).filter(Boolean));
   }

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

@@ -0,0 +1,75 @@
+/*
+ * 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/no-choice-control-wrapper.js

@@ -25,6 +25,7 @@ function handedTo(element, owner) {
 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;
@@ -39,6 +40,7 @@ function invoked(handler) {
     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);
       }
     }

package/dist/eslint/rules/no-decorative-icon.js

@@ -0,0 +1,164 @@
+/*
+ * Standard tool checked first: a `no-restricted-syntax` selector such as
+ * `CardTitle JSXOpeningElement` matches any element under a title, not the
+ * ones bound to an icon module, and cannot stop at a control between the two
+ * (`<CardHeader><Button><Plus/></Button></CardHeader>` is allowed). This rule
+ * joins the element to its import and reads the nearest container above it.
+ */
+import { renderedImports, sourceMatches, writtenName } from "./rendered-import.js";
+
+export const noDecorativeIcon = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "A title or a label carries no icon; an icon belongs to a control or a menu row.",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          iconModules: { type: "array", items: { type: "string" }, uniqueItems: true },
+          headings: { type: "array", items: { type: "string" }, uniqueItems: true },
+          controls: { type: "array", items: { type: "string" }, uniqueItems: true },
+        },
+        additionalProperties: false,
+      },
+    ],
+    defaultOptions: [
+      {
+        iconModules: ["lucide-react", "@nadicodeai/ui/components/house-icons"],
+        headings: [
+          "h1",
+          "h2",
+          "h3",
+          "h4",
+          "h5",
+          "h6",
+          "legend",
+          "dt",
+          "th",
+          "caption",
+          "CardTitle",
+          "CardDescription",
+          "CardHeader",
+          "DialogTitle",
+          "SheetTitle",
+          "AlertDialogTitle",
+          "DrawerTitle",
+          "FieldLabel",
+          "FieldLegend",
+          "Label",
+          "ItemTitle",
+          "TableHead",
+        ],
+        controls: [
+          "button",
+          "a",
+          "Button",
+          "Link",
+          "CardAction",
+          "TabsTrigger",
+          "TabsLink",
+          "ToggleGroupItem",
+          "Toggle",
+          "SidebarMenuButton",
+          "InputGroupAddon",
+          "InputGroupButton",
+        ],
+      },
+    ],
+    messages: {
+      "beside-heading":
+        "A title or a label carries no icon: an identity mark starts a row or a card (IdentityMark), and an icon belongs to a control or a menu row.",
+    },
+  },
+  create(context) {
+    const [{ iconModules, headings, controls }] = context.options;
+    const headingNames = new Set(headings);
+    const controlNames = new Set(controls);
+    const importOf = renderedImports(context);
+    const isIconImport = (name) => {
+      const imported = importOf({ type: "JSXIdentifier", name });
+      return (
+        imported !== null &&
+        iconModules.some((module) => sourceMatches(imported.source, module, context.filename))
+      );
+    };
+
+    function constantOf(name, scope) {
+      for (let current = scope; current; current = current.upper) {
+        const variable = current.set.get(name);
+        if (!variable) continue;
+        const [definition] = variable.defs;
+        const declared =
+          definition?.type === "Variable" && definition.parent.kind === "const"
+            ? definition.node.init
+            : null;
+        return declared ?? null;
+      }
+      return null;
+    }
+
+    function holdsAnIcon(value, scope, seen = new Set()) {
+      if (!value || seen.has(value)) return false;
+      seen.add(value);
+      switch (value.type) {
+        case "Identifier":
+          return (
+            isIconImport(value.name) || holdsAnIcon(constantOf(value.name, scope), scope, seen)
+          );
+        case "MemberExpression":
+          return holdsAnIcon(value.object, scope, seen);
+        case "ConditionalExpression":
+          return [value.consequent, value.alternate].some((branch) =>
+            holdsAnIcon(branch, scope, seen),
+          );
+        case "LogicalExpression":
+          return [value.left, value.right].some((side) => holdsAnIcon(side, scope, seen));
+        case "ObjectExpression":
+          return value.properties.some(
+            (property) => property.type === "Property" && holdsAnIcon(property.value, scope, seen),
+          );
+        case "ArrayExpression":
+          return value.elements.some((element) => holdsAnIcon(element, scope, seen));
+        default:
+          return false;
+      }
+    }
+
+    function isIcon(openingElement) {
+      const imported = importOf(openingElement.name);
+      if (imported) {
+        return iconModules.some((module) =>
+          sourceMatches(imported.source, module, context.filename),
+        );
+      }
+      const { name } = openingElement;
+      if (name.type !== "JSXIdentifier" || !/^[A-Z]/.test(name.name)) return false;
+      const scope = context.sourceCode.getScope(openingElement);
+      return holdsAnIcon(constantOf(name.name, scope), scope);
+    }
+
+    return {
+      JSXOpeningElement(node) {
+        if (!isIcon(node)) return;
+        for (let current = node.parent.parent; current; current = current.parent) {
+          if (current.type === "JSXAttribute") {
+            if (headingNames.has(writtenName(current.parent.name))) {
+              context.report({ node, messageId: "beside-heading" });
+            }
+            return;
+          }
+          if (current.type !== "JSXElement") continue;
+          const name = writtenName(current.openingElement.name);
+          if (controlNames.has(name)) return;
+          if (headingNames.has(name)) {
+            context.report({ node, messageId: "beside-heading" });
+            return;
+          }
+        }
+      },
+    };
+  },
+};

package/dist/eslint/rules/no-deprecated-zod-api.js

@@ -103,6 +103,7 @@ function memberName(node) {
     return node.property.name;
   }
   if (node.computed && node.property.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 node.property.value === "string" ? node.property.value : undefined;
   }
   return undefined;

package/dist/eslint/rules/no-shadcn-appearance-override.js

@@ -138,6 +138,7 @@ function inlineAppearanceProperties(attribute) {
           : undefined;
     if (!appearanceStyleProperties.has(name)) return false;
     const value = staticStyleValue(property.value);
+    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- staticStyleValue returns the literal's string, number or undefined; only typeof tells them apart.
     return typeof value === "number" || (typeof value === "string" && value.trim() !== "");
   });
 }

package/dist/eslint/rules/no-subject-derived-expectation.js

@@ -43,6 +43,7 @@ import { dirname, resolve, sep } from "node:path";
 function propertyName(member) {
   if (!member.computed && member.property.type === "Identifier") return member.property.name;
   if (member.computed && member.property.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 member.property.value === "string" ? member.property.value : undefined;
   }
   return undefined;
@@ -148,7 +149,6 @@ export const noSubjectDerivedExpectation = {
           if (statement.type !== "ImportDeclaration") continue;
           if (statement.importKind === "type") continue;
           const source = statement.source.value;
-          if (typeof source !== "string") continue;
           if (!source.startsWith("./") && !source.startsWith("../")) continue;
           if (isHarnessModule(context.filename, source)) continue;
           for (const specifier of statement.specifiers) {

package/dist/eslint/rules/no-write-in-subscription.js

@@ -77,6 +77,7 @@ function* writesIn(node, keys) {
   for (const key of keys[node.type] ?? []) {
     const child = node[key];
     for (const each of Array.isArray(child) ? child : [child]) {
+      // 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 (each && typeof each.type === "string") yield* writesIn(each, keys);
     }
   }