@nadicodeai/ui 12.1.53 → 12.1.55

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

package/dist/eslint/rules/no-native-visible-control.js

@@ -1,92 +0,0 @@
-import { packageOwnedPrimitivesSchema, skipsPackageOwnedPrimitive } from "./jsx-class-utility.js";
-
-const NATIVE_CONTROLS = new Set(["button", "details", "input", "select", "textarea"]);
-
-function staticValue(node) {
-  if (node?.type === "Literal") {
-    return node.value;
-  }
-  if (node?.type === "JSXExpressionContainer") {
-    return staticValue(node.expression);
-  }
-  if (node?.type === "TemplateLiteral" && node.expressions.length === 0) {
-    return node.quasis[0]?.value.cooked;
-  }
-  return undefined;
-}
-
-function hiddenInput(node) {
-  const typeAttribute = node.attributes.find(
-    (attribute) => attribute.type === "JSXAttribute" && attribute.name.name === "type",
-  );
-  return staticValue(typeAttribute?.value) === "hidden";
-}
-
-function isPrimitiveRenderElement(node, packagePrimitiveNames) {
-  const expression = node.parent;
-  const attribute = expression?.parent;
-  const openingElement = attribute?.parent;
-  return (
-    expression?.type === "JSXExpressionContainer" &&
-    attribute?.type === "JSXAttribute" &&
-    attribute.name.name === "render" &&
-    openingElement?.type === "JSXOpeningElement" &&
-    openingElement.name.type === "JSXIdentifier" &&
-    packagePrimitiveNames.has(openingElement.name.name)
-  );
-}
-
-export const noNativeVisibleControl = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow visible native controls in app source; use @nadicodeai/ui primitives",
-    },
-    // Default "exempt": the package's own source is where the primitives that
-    // replace a native control are built, so a native <button> there is the
-    // implementation, not a bypass.
-    schema: [packageOwnedPrimitivesSchema],
-    messages: {
-      nativeVisibleControl:
-        "Use the @nadicodeai/ui primitive instead of native visible <{{element}}>{{hint}}.",
-    },
-  },
-  create(context) {
-    if (skipsPackageOwnedPrimitive(context)) {
-      return {};
-    }
-    const packagePrimitiveNames = new Set();
-    return {
-      ImportDeclaration(node) {
-        if (
-          typeof node.source.value !== "string" ||
-          !node.source.value.startsWith("@nadicodeai/ui")
-        ) {
-          return;
-        }
-        for (const specifier of node.specifiers) {
-          packagePrimitiveNames.add(specifier.local.name);
-        }
-      },
-      JSXOpeningElement(node) {
-        if (node.name.type !== "JSXIdentifier" || !NATIVE_CONTROLS.has(node.name.name)) {
-          return;
-        }
-        if (node.name.name === "input" && hiddenInput(node)) {
-          return;
-        }
-        if (isPrimitiveRenderElement(node.parent, packagePrimitiveNames)) {
-          return;
-        }
-        context.report({
-          node: node.name,
-          messageId: "nativeVisibleControl",
-          data: {
-            element: node.name.name,
-            hint: node.name.name === "details" ? ": Disclosure draws the one disclosure" : "",
-          },
-        });
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-nested-overlay.js

@@ -1,56 +0,0 @@
-/*
- * One overlay at a time.
- *
- * `DialogContent`, `AlertDialogContent`, `SheetContent` and `DrawerContent` each
- * mount a focus trap, a scrim and a layer of their own. Writing one inside
- * another leaves both traps armed on the same tree: focus cannot leave the inner
- * surface to reach the outer one's controls, Escape resolves against whichever
- * trap won the race, and the two scrims composite into a second dim over content
- * that is already dimmed. Nothing about this is visible while the inner overlay
- * is closed, which is why it survives review and reaches the keyboard user.
- *
- * Standard tool checked first: `no-restricted-syntax` selects one node by its
- * shape and cannot ask what encloses it. "An overlay inside an overlay" is a
- * relationship between two elements, so it is read here, on the shared
- * component-name reader that also resolves renamed imports.
- */
-import { jsxComponentName } from "./jsx-class-utility.js";
-
-const OVERLAY_CONTENT = new Set([
-  "AlertDialogContent",
-  "DialogContent",
-  "DrawerContent",
-  "SheetContent",
-]);
-
-export const noNestedOverlay = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow an overlay surface rendered inside another overlay surface",
-    },
-    schema: [],
-    messages: {
-      nestedOverlay:
-        "<{{inner}}> is rendered inside <{{outer}}>. Two overlays on one tree keep both focus traps armed, so the keyboard cannot reach the outer surface and Escape closes the wrong layer, while the scrims stack. Render the second overlay as a sibling driven by state, or replace it with an inline disclosure inside the first.",
-    },
-  },
-  create(context) {
-    return {
-      JSXOpeningElement(node) {
-        const inner = jsxComponentName(node, context);
-        if (!inner || !OVERLAY_CONTENT.has(inner)) return;
-
-        for (const ancestor of context.sourceCode.getAncestors(node)) {
-          // The element this opening tag belongs to is an ancestor of it, and it
-          // is not nested inside itself.
-          if (ancestor.type !== "JSXElement" || ancestor.openingElement === node) continue;
-          const outer = jsxComponentName(ancestor.openingElement, context);
-          if (!outer || !OVERLAY_CONTENT.has(outer)) continue;
-          context.report({ node, messageId: "nestedOverlay", data: { inner, outer } });
-          return;
-        }
-      },
-    };
-  },
-};