@nadicodeai/ui 8.5.0 → 8.6.0

package/dist/eslint/index.js

@@ -6,6 +6,7 @@ import { confirmDestructiveAction } from "./rules/confirm-destructive-action.js"
 import { iconControlAccessibleName } from "./rules/icon-control-accessible-name.js";
 import { noAppFeatureComponent } from "./rules/no-app-feature-component.js";
 import { noElevatedEdge } from "./rules/no-elevated-edge.js";
+import { noExistenceOnlyAssertion } from "./rules/no-existence-only-assertion.js";
 import { noNestedOverlay } from "./rules/no-nested-overlay.js";
 import { noOffGridSpacing } from "./rules/no-off-grid-spacing.js";
 import { noRawShadow } from "./rules/no-raw-shadow.js";
@@ -17,6 +18,7 @@ import { noPackageComponentRedefinition } from "./rules/no-package-component-red
 import { noPairedSizeUtility } from "./rules/no-paired-size-utility.js";
 import { noRestingSettingsControl } from "./rules/no-resting-settings-control.js";
 import { noShadcnAppearanceOverride } from "./rules/no-shadcn-appearance-override.js";
+import { noSubjectDerivedExpectation } from "./rules/no-subject-derived-expectation.js";
 import { noUnpinnedVercelFunctionsImport } from "./rules/no-unpinned-vercel-functions-import.js";
 import { noNativeVisibleControl } from "./rules/no-native-visible-control.js";
 import { noRepaintedFocus } from "./rules/no-repainted-focus.js";
@@ -84,6 +86,7 @@ const plugin = {
     "icon-control-accessible-name": iconControlAccessibleName,
     "no-app-feature-component": noAppFeatureComponent,
     "no-elevated-edge": noElevatedEdge,
+    "no-existence-only-assertion": noExistenceOnlyAssertion,
     "no-deprecated-zod-api": noDeprecatedZodApi,
     "no-mono-title-register": noMonoTitleRegister,
     "no-nested-overlay": noNestedOverlay,
@@ -95,6 +98,7 @@ const plugin = {
     "no-route-width-override": noRouteWidthOverride,
     "prefer-radio-for-few-static-options": preferRadioForFewStaticOptions,
     "no-shadcn-appearance-override": noShadcnAppearanceOverride,
+    "no-subject-derived-expectation": noSubjectDerivedExpectation,
     "no-native-visible-control": noNativeVisibleControl,
     "no-repainted-focus": noRepaintedFocus,
     "no-unpinned-vercel-functions-import": noUnpinnedVercelFunctionsImport,

package/dist/eslint/rules/expect-chain.js

@@ -0,0 +1,60 @@
+/*
+ * One reader for `expect(subject).<modifiers>.<matcher>(args)`.
+ *
+ * Both assertion rules here judge a call by its matcher name, and the matcher
+ * is not the callee's property in the general case: `not`, `resolves` and
+ * `rejects` sit between `expect(...)` and the matcher, so the name has to be
+ * read by walking the member chain back to the `expect` call. This is that
+ * walk, kept in one place so the two rules cannot disagree about what counts
+ * as an assertion.
+ */
+
+function propertyName(member) {
+  if (!member.computed && member.property.type === "Identifier") return member.property.name;
+  if (member.computed && member.property.type === "Literal") {
+    return typeof member.property.value === "string" ? member.property.value : undefined;
+  }
+  return undefined;
+}
+
+/** `a?.b` and `a?.()` arrive wrapped; the rules want the expression itself. */
+function unwrapChain(node) {
+  return node?.type === "ChainExpression" ? node.expression : node;
+}
+
+function isExpectCall(node) {
+  if (node?.type !== "CallExpression") return false;
+  if (node.callee.type === "Identifier") return node.callee.name === "expect";
+  // `expect.soft(value)` and `expect.poll(fn)` open the same chain.
+  return node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier"
+    ? node.callee.object.name === "expect"
+    : false;
+}
+
+/**
+ * Reads an assertion call. Returns `{ matcher, modifiers, subject, args }` for
+ * `expect(subject).<modifiers>.<matcher>(args)`, or `undefined` when the call
+ * is not an `expect` chain. `subject` is unwrapped of its `ChainExpression`.
+ */
+export function expectAssertion(node) {
+  if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") return undefined;
+  const matcher = propertyName(node.callee);
+  if (!matcher) return undefined;
+
+  const modifiers = [];
+  let current = node.callee.object;
+  while (current.type === "MemberExpression") {
+    const name = propertyName(current);
+    if (!name) return undefined;
+    modifiers.unshift(name);
+    current = current.object;
+  }
+  if (!isExpectCall(current)) return undefined;
+
+  return {
+    matcher,
+    modifiers,
+    subject: unwrapChain(current.arguments[0]),
+    args: node.arguments,
+  };
+}

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

@@ -0,0 +1,89 @@
+/*
+ * 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-subject-derived-expectation.js

@@ -0,0 +1,129 @@
+/*
+ * The expected value cannot come out of the module under test.
+ *
+ * When a test compares a result with a constant it imported from the sibling
+ * module it is testing, both sides move together: editing the implementation
+ * edits the expectation, and no change to the value can ever turn the test
+ * red. What looks like a pinned contract is a restatement of the code.
+ *
+ * Three of these were live here. `viewer-time-zone.test.ts` asserted
+ * `expect(await viewerTimeZone()).toBe(DEFAULT_VIEWER_TIME_ZONE)` with
+ * `DEFAULT_VIEWER_TIME_ZONE` imported from `./viewer-time-zone`, so the
+ * default the Portal falls back to was never pinned to a time zone at all.
+ * `contract-v1.test.ts` asserted the served ETag header against
+ * `openApiV1Etag` from `./contract-v1`, so the published API contract's
+ * validator was compared with itself, and a token TTL went the same way.
+ *
+ * The fix is to write the literal (`"Europe/Rome"`), or to compute the
+ * expectation from something the subject does not own — a checked-in fixture,
+ * a hash taken in the test, the wire format itself.
+ *
+ * Scope: only a relative import (`./`, `../`) is the subject. A constant from
+ * a package or an alias (`@/…`, `vitest`) is a third party's contract, and a
+ * value the test file declares itself is a value the test chose. Only a bare
+ * identifier or a member read off one counts: a call, a template literal or a
+ * literal built around the identifier is a transformation the test performs,
+ * and the transformation is the thing being asserted.
+ *
+ * A relative import that resolves into a `tests/` or `fixtures/` directory is
+ * the harness, not the subject: `PORTAL_TEST_ADMIN.userId` from
+ * `apps/portal/tests/support/postgres-testdb` is the row the test seeded, so
+ * comparing a query result with it asserts that the code returned what was put
+ * in. Those are excluded by the resolved path, not by the specifier, because a
+ * test under `tests/` reaches its own support modules as `../support/…`.
+ */
+import { dirname, resolve, sep } from "node:path";
+
+import { expectAssertion } from "./expect-chain.js";
+
+const EQUALITY_MATCHERS = new Set(["toBe", "toEqual", "toStrictEqual"]);
+const TEST_FILE = /\.test\.tsx?$/;
+const HARNESS_DIRECTORIES = new Set(["tests", "test", "__tests__", "fixtures", "__fixtures__"]);
+
+/** True when the import lands in a directory the test side owns. */
+function isHarnessModule(filename, source) {
+  const resolved = resolve(dirname(filename), source);
+  const segments = resolved.split(sep);
+  if (segments.some((segment) => HARNESS_DIRECTORIES.has(segment))) return true;
+  // `openrouter-wire.fixture.ts` beside its subject: a fixture by name, not by directory.
+  return /\.fixture(\.[cm]?[jt]sx?)?$/.test(segments[segments.length - 1]);
+}
+
+/** The identifier a bare read or a member read (`contract.etag`) starts from. */
+function rootIdentifier(node) {
+  let current = node;
+  while (current?.type === "MemberExpression" || current?.type === "ChainExpression") {
+    current = current.type === "ChainExpression" ? current.expression : current.object;
+  }
+  return current?.type === "Identifier" ? current : undefined;
+}
+
+export const noSubjectDerivedExpectation = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow an expected value imported from the sibling module the test covers",
+    },
+    schema: [],
+    messages: {
+      subjectDerived:
+        "`{{name}}` comes from `{{source}}`, the module this test covers, so the expectation moves with the implementation and no change to that value can fail this test. Write the expected value as a literal here, or compute it from something the subject does not own.",
+    },
+  },
+
+  create(context) {
+    if (!TEST_FILE.test(context.filename)) return {};
+
+    const sourceCode = context.sourceCode;
+    /** @type {Map<import('eslint').Scope.Variable, string>} */
+    const subjectBindings = new Map();
+
+    function bindingSource(identifier) {
+      for (let scope = sourceCode.getScope(identifier); scope; scope = scope.upper) {
+        const variable = scope.set.get(identifier.name);
+        // The nearest binding wins: a local declaration shadowing the import
+        // is a value this test chose, so it drops out here.
+        if (variable) return subjectBindings.get(variable);
+      }
+      return undefined;
+    }
+
+    return {
+      Program(node) {
+        for (const statement of node.body) {
+          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) {
+            if (specifier.importKind === "type") continue;
+            for (const variable of sourceCode.getDeclaredVariables(specifier)) {
+              subjectBindings.set(variable, source);
+            }
+          }
+        }
+      },
+
+      CallExpression(node) {
+        const assertion = expectAssertion(node);
+        if (!assertion || !EQUALITY_MATCHERS.has(assertion.matcher)) return;
+        const [expected] = assertion.args;
+        if (!expected) return;
+        if (expected.type !== "Identifier" && expected.type !== "MemberExpression") return;
+
+        const root = rootIdentifier(expected);
+        if (!root) return;
+        const source = bindingSource(root);
+        if (!source) return;
+
+        context.report({
+          node: expected,
+          messageId: "subjectDerived",
+          data: { name: sourceCode.getText(expected), source },
+        });
+      },
+    };
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nadicodeai/ui",
-  "version": "8.5.0",
+  "version": "8.6.0",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -70,7 +70,7 @@
     "@assistant-ui/react": "0.15.20",
     "@assistant-ui/react-markdown": "0.14.15",
     "@base-ui/react": "^1.8.0",
-    "@nadicodeai/design-system": "8.5.0",
+    "@nadicodeai/design-system": "8.6.0",
     "@paper-design/shaders": "0.0.81",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",