@nadicodeai/ui 12.1.165 → 12.1.167

package/dist/eslint/rules/no-search-in-form.js

@@ -1,47 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` descendant selector
- * (`JSXElement[openingElement.name.name=/Form$/] JSXOpeningElement`) matches by
- * element name, so it cannot tell the package's CollectionSearch from a local
- * component of the same name, nor a renamed import.
- */
-import { packageModules, partOf, renderedImports, writtenName } from "./rendered-import.js";
-
-const COLLECTION_SEARCH = new Map([
-  [
-    "CollectionSearch",
-    packageModules("collection-search").map((from) => ({ from, part: "CollectionSearch" })),
-  ],
-]);
-
-const isForm = (element) => {
-  const name = writtenName(element.openingElement.name);
-  return name === "form" || name?.endsWith("Form") === true;
-};
-
-export const noSearchInForm = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "A collection's search sits in its toolbar, never inside a form that saves.",
-    },
-    schema: [],
-    messages: {
-      "search-in-form":
-        "A search box does not belong in a form that saves something; a collection's search sits in its toolbar.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    return {
-      JSXOpeningElement(node) {
-        if (partOf(importOf(node.name), COLLECTION_SEARCH, context.filename) === null) return;
-        for (let ancestor = node.parent.parent; ancestor; ancestor = ancestor.parent) {
-          if (ancestor.type === "JSXElement" && isForm(ancestor)) {
-            context.report({ node, messageId: "search-in-form" });
-            return;
-          }
-        }
-      },
-    };
-  },
-};

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

@@ -1,305 +0,0 @@
-/*
- * The design system (`packages/design-system/DESIGN.md`, "Components"): "A page
- * arranges and sizes a component and never restyles it: a new appearance is a
- * typed variant or slot added to the component." A caller that
- * repaints an imported primitive forks its appearance into the call site, where
- * the next token change does not reach it.
- *
- * The theme's palette restriction (design-system, #821) removed the raw
- * Tailwind palette, so `bg-red-500` is no longer a class anywhere. What it did
- * NOT remove is repainting with the SEMANTIC roles — `bg-background`,
- * `text-foreground`, `rounded-xl`, `shadow-lg`, `opacity-50`, `border-0` — all
- * of which still compile and still fork the primitive. Those are what survives
- * here; the raw-palette names are gone from the sets below with the palette.
- */
-import { posix } from "node:path";
-
-import {
-  classUtilities,
-  openingElementClassUtilities,
-  packageOwnedPrimitivesSchema,
-  skipsPackageOwnedPrimitive,
-} from "./jsx-class-utility.js";
-
-// This exact Portal adapter forwards props to package primitives. Card
-// chooses its typed surface default. Its other exports are direct reexports.
-const portalCardExports = new Set([
-  "Card",
-  "CardHeader",
-  "CardTitle",
-  "CardDescription",
-  "CardAction",
-  "CardContent",
-]);
-
-function primitiveModule(source, filename) {
-  if (source.startsWith("@nadicodeai/ui/components/")) {
-    return { card: source === "@nadicodeai/ui/components/card", exports: undefined };
-  }
-  const normalized = filename.replaceAll("\\", "/");
-  const portalStart = normalized.lastIndexOf("/apps/portal/src/");
-  if (portalStart === -1) return undefined;
-  const portalSource = `${normalized.slice(0, portalStart)}/apps/portal/src`;
-  const resolved = source.startsWith(".")
-    ? posix.normalize(posix.join(posix.dirname(normalized), source)).replace(/\.[jt]sx?$/, "")
-    : undefined;
-  if (source === "@/components/kit/card" || resolved === `${portalSource}/components/kit/card`) {
-    return { card: true, exports: portalCardExports };
-  }
-  return undefined;
-}
-
-function primitiveExport(module, name) {
-  if (module.exports && !module.exports.has(name)) return undefined;
-  return { cardRoot: module.card && name === "Card" };
-}
-
-const appearanceStyleProperties = new Set([
-  "appearance",
-  "WebkitAppearance",
-  "MozAppearance",
-  "color",
-  "background",
-  "backgroundColor",
-  "backgroundImage",
-  "boxShadow",
-  "textShadow",
-  "opacity",
-  "outlineColor",
-  "filter",
-  "backdropFilter",
-  "WebkitBackdropFilter",
-  "fill",
-  "fillOpacity",
-  "stroke",
-  "strokeOpacity",
-  ...[
-    "",
-    "Top",
-    "Right",
-    "Bottom",
-    "Left",
-    "Block",
-    "Inline",
-    "BlockStart",
-    "BlockEnd",
-    "InlineStart",
-    "InlineEnd",
-  ].map((side) => `border${side}Color`),
-  ...[
-    "",
-    "TopLeft",
-    "TopRight",
-    "BottomLeft",
-    "BottomRight",
-    "StartStart",
-    "StartEnd",
-    "EndStart",
-    "EndEnd",
-  ].map((corner) => `border${corner}Radius`),
-]);
-
-function staticStyleValue(node) {
-  if (node.type === "Literal") return node.value;
-  if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
-    return node.quasis[0]?.value.cooked;
-  }
-  return undefined;
-}
-
-// Inline object literals only. Unknown values, computed keys, imported style
-// objects and spreads remain review work; layout properties are not paint.
-function inlineAppearanceProperties(attribute) {
-  if (attribute.type !== "JSXAttribute" || attribute.name.name !== "style") return [];
-  const expression =
-    attribute.value?.type === "JSXExpressionContainer" ? attribute.value.expression : undefined;
-  if (expression?.type !== "ObjectExpression") return [];
-  return expression.properties.filter((property) => {
-    if (property.type !== "Property") return false;
-    const name =
-      property.key.type === "Literal"
-        ? property.key.value
-        : !property.computed && property.key.type === "Identifier"
-          ? property.key.name
-          : 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() !== "");
-  });
-}
-
-function withoutVariants(utility) {
-  return utility.slice(utility.lastIndexOf(":") + 1);
-}
-
-function isTypographySize(utility) {
-  return /^text-(?:xs|sm|base|lg|xl|[2-9]xl|\[[\d.]+(?:px|rem|em|%|lh)\])$/.test(utility);
-}
-
-function isTextLayoutUtility(utility) {
-  return /^text-(?:left|center|right|justify|start|end|balance|pretty|clip|ellipsis)$/.test(
-    utility,
-  );
-}
-
-function isBorderMechanic(utility) {
-  return /^(?:border(?:-(?:[xy]|[trblse]{1,2}|[0-9]+|px|dashed|dotted|double|hidden|none))?)$/.test(
-    utility,
-  );
-}
-
-function isBorderRemoval(utility) {
-  return /^border(?:-[xytrblse]{1,2})?-(?:0|none|\[(?:length:)?0(?:px|rem|em|%)?\])$/.test(utility);
-}
-
-function isRingOrOutlineMechanic(utility) {
-  return /^(?:ring(?:-(?:[0-9]+|inset|offset(?:-[0-9]+)?))?|outline(?:-(?:none|[0-9]+|offset-[0-9]+))?)$/.test(
-    utility,
-  );
-}
-
-/*
- * A border/ring/outline utility is either one of the enumerated MECHANICS
- * (width, side, style, inset/offset — structure the caller owns) or it paints.
- * There is no third case left to test for: the palette restriction means an
- * unrecognised `border-…` value is not a class, and
- * `better-tailwindcss/no-unknown-classes` reports it as one. That is what
- * retired the hand-written colour-name list this rule used to carry.
- */
-function isAppearanceUtility(utility) {
-  const base = withoutVariants(utility);
-  return (
-    /^appearance-/.test(base) ||
-    /^bg-/.test(base) ||
-    isBorderRemoval(base) ||
-    (base.startsWith("border") && !isBorderMechanic(base)) ||
-    /^shadow(?:-|$)/.test(base) ||
-    /^rounded(?:-|$)/.test(base) ||
-    ((base.startsWith("ring") || base.startsWith("outline")) && !isRingOrOutlineMechanic(base)) ||
-    /^opacity-/.test(base) ||
-    (/^text-/.test(base) && !isTypographySize(base) && !isTextLayoutUtility(base))
-  );
-}
-
-function isProhibitedAppearanceUtility(utility, { cardRoot = false } = {}) {
-  const base = withoutVariants(utility);
-  return (
-    targetsSharedSlot(utility) ||
-    (isAppearanceUtility(utility) && (!isBorderRemoval(base) || cardRoot))
-  );
-}
-
-function targetsSharedSlot(utility) {
-  return utility.includes("data-slot") || utility.includes("data-[slot");
-}
-
-function targetsCardSlot(utility) {
-  return (
-    /data-slot=(?:card|["']card["'])(?=\])/.test(utility) ||
-    /data-\[slot=(?:card|["']card["'])\]/.test(utility)
-  );
-}
-
-export const noShadcnAppearanceOverride = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Keep shared component appearance and internal slot layout at their owner",
-    },
-    // Default "exempt": inside @nadicodeai/ui the primitives ARE the appearance,
-    // so every utility here would be a false positive.
-    schema: [packageOwnedPrimitivesSchema],
-    messages: {
-      appearanceOverride:
-        "Do not override shared component appearance or internal slot layout with {{utility}}; use a component prop or fix its shared owner.",
-    },
-  },
-  create(context) {
-    if (skipsPackageOwnedPrimitive(context)) {
-      return {};
-    }
-
-    const sourceCode = context.sourceCode;
-    const sharedBindings = new Map();
-
-    function importedBinding(identifier) {
-      for (let scope = sourceCode.getScope(identifier); scope; scope = scope.upper) {
-        const variable = scope.set.get(identifier.name);
-        if (variable) return sharedBindings.get(variable);
-      }
-      return undefined;
-    }
-
-    function sharedPrimitive(node) {
-      if (node?.type !== "JSXOpeningElement") return undefined;
-      if (node.name.type === "JSXIdentifier") {
-        const binding = importedBinding(node.name);
-        return binding && binding.name !== "*"
-          ? primitiveExport(binding.module, binding.name)
-          : undefined;
-      }
-      if (node.name.type === "JSXMemberExpression" && node.name.object.type === "JSXIdentifier") {
-        const binding = importedBinding(node.name.object);
-        return binding?.name === "*"
-          ? primitiveExport(binding.module, node.name.property.name)
-          : undefined;
-      }
-      return undefined;
-    }
-
-    return {
-      Program(node) {
-        // Imports are hoisted; collect their declared variables before visiting
-        // JSX. Binding identity also distinguishes shadowing parameters/locals.
-        for (const declaration of node.body) {
-          if (declaration.type !== "ImportDeclaration" || declaration.importKind === "type")
-            continue;
-          const module = primitiveModule(declaration.source.value, context.filename);
-          if (!module) continue;
-          for (const specifier of declaration.specifiers) {
-            if (specifier.importKind === "type") continue;
-            const name =
-              specifier.type === "ImportNamespaceSpecifier"
-                ? "*"
-                : specifier.type === "ImportSpecifier"
-                  ? (specifier.imported.name ?? specifier.imported.value)
-                  : "default";
-            for (const variable of sourceCode.getDeclaredVariables(specifier)) {
-              sharedBindings.set(variable, { module, name });
-            }
-          }
-        }
-      },
-      JSXOpeningElement(node) {
-        const primitive = sharedPrimitive(node);
-        if (!primitive) return;
-        for (const utility of openingElementClassUtilities(node, context, true)) {
-          if (utility && isProhibitedAppearanceUtility(utility, primitive)) {
-            context.report({ node, messageId: "appearanceOverride", data: { utility } });
-          }
-        }
-        for (const property of node.attributes.flatMap(inlineAppearanceProperties)) {
-          const name = property.key.name ?? property.key.value;
-          context.report({
-            node: property,
-            messageId: "appearanceOverride",
-            data: { utility: `style.${name}` },
-          });
-        }
-      },
-      JSXAttribute(node) {
-        if (sharedPrimitive(node.parent)) return;
-        for (const utility of classUtilities(node, context)) {
-          if (
-            !targetsSharedSlot(utility) ||
-            !isProhibitedAppearanceUtility(utility, { cardRoot: targetsCardSlot(utility) })
-          ) {
-            continue;
-          }
-          context.report({ node, messageId: "appearanceOverride", data: { utility } });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-shell-prompt-in-snippet.js

@@ -1,74 +0,0 @@
-/*
- * A Snippet draws its own prompt and copies only the command, so a `$ ` or `> `
- * typed into `text` shows twice and is on the clipboard.
- *
- * Standard tool checked first: `no-restricted-syntax` can match a string
- * starting with `$ `, but not whether it is the `text` of the package's Snippet
- * (an import binding, so a renamed or local `Snippet` is judged correctly),
- * and it cannot read the items of an array or exempt `prompt={false}`.
- */
-import { partOf, renderedImports, staticAttribute } from "./rendered-import.js";
-
-const SNIPPET = new Map([
-  [
-    "Snippet",
-    [
-      { from: "@nadicodeai/ui/components/snippet", part: "Snippet" },
-      { from: "@nadicodeai/ui", part: "Snippet" },
-    ],
-  ],
-]);
-const OWNER_FILE = "packages/ui/src/components/snippet.tsx";
-
-const startsWithPrompt = (text) => text === "$" || text.startsWith("$ ") || text.startsWith("> ");
-
-function writtenText(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") return typeof node.value === "string" ? node.value : null;
-  if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
-    return node.quasis[0].value.cooked;
-  }
-  return null;
-}
-
-function promptedItems(value) {
-  if (!value) return [];
-  const written = value.type === "JSXExpressionContainer" ? value.expression : value;
-  const items = written.type === "ArrayExpression" ? written.elements : [written];
-  return items.filter((item) => {
-    if (!item || item.type === "SpreadElement") return false;
-    const text = writtenText(item);
-    return text !== null && startsWithPrompt(text);
-  });
-}
-
-export const noShellPromptInSnippet = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "A Snippet's text never starts with the prompt the Snippet draws.",
-    },
-    schema: [],
-    messages: {
-      "typed-prompt":
-        'The Snippet draws the prompt. Remove the leading "$ " from text, or pass prompt={false} when the value is not a shell command.',
-    },
-  },
-  create(context) {
-    if (context.filename.replaceAll("\\", "/").endsWith(`/${OWNER_FILE}`)) return {};
-    const importOf = renderedImports(context);
-
-    return {
-      JSXOpeningElement(node) {
-        if (partOf(importOf(node.name), SNIPPET, context.filename) !== "Snippet") return;
-        if (staticAttribute(node, "prompt") === false) return;
-        const text = node.attributes.find(
-          (attribute) => attribute.type === "JSXAttribute" && attribute.name.name === "text",
-        );
-        for (const item of promptedItems(text?.value)) {
-          context.report({ node: item, messageId: "typed-prompt" });
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-stock-error-words.js

@@ -1,56 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-syntax` matches a string by one
- * regular expression per selector and would need one entry per phrase and per
- * node kind (a literal, a template's text, JSX text); one rule lists the
- * phrases once and reads them in the catalogue files only, by path.
- */
-import { literalText } from "./literal-text.js";
-
-const PHRASES = [
-  ["Something went wrong", /\bsomething went wrong\b/i],
-  ["Unable to", /\bunable to\b/i],
-  ["Heads up", /\bheads[ -]up\b/i],
-  ["please", /\bplease\b/i],
-  ["successfully", /\bsuccessfully\b/i],
-];
-
-const CATALOGUE_FILE = /(?:^|\/)(?:copy|i18n)\/|(?:^|\/)(?:words|messages)\.[jt]s$/;
-const TEST_FILE = /\.test(?:-[^./]+)?\.[jt]sx?$/;
-
-export const noStockErrorWords = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        'A catalogue message never says "Something went wrong", "Unable to", "Heads up", "please" or "successfully".',
-    },
-    schema: [],
-    messages: {
-      "stock-phrase":
-        'A catalogue message does not say "{{phrase}}": name what happened to which record and what the person can do, in the active voice ("Couldn\'t pause Discord. The Gateway didn\'t answer."), with no please and no "successfully".',
-    },
-  },
-  create(context) {
-    const filename = context.filename.replaceAll("\\", "/");
-    if (!CATALOGUE_FILE.test(filename) || TEST_FILE.test(filename)) return {};
-
-    function check(node, text) {
-      if (text === null) return;
-      for (const [phrase, pattern] of PHRASES) {
-        if (pattern.test(text))
-          context.report({ node, messageId: "stock-phrase", data: { phrase } });
-      }
-    }
-
-    return {
-      Literal(node) {
-        if (node.parent.type === "ImportDeclaration" || node.parent.type === "ExportAllDeclaration")
-          return;
-        check(node, literalText(node));
-      },
-      TemplateElement(node) {
-        check(node, node.value.cooked);
-      },
-    };
-  },
-};

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

@@ -1,183 +0,0 @@
-/*
- * 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";
-
-/*
- * The matcher of `expect(subject).<modifiers>.<matcher>(args)` is not the
- * callee's property in the general case: `not`, `resolves` and `rejects` sit
- * between `expect(...)` and the matcher, so it is read by walking the member
- * chain back to the `expect` call.
- */
-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;
-}
-
-/** `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`.
- */
-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,
-  };
-}
-
-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 (!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 },
-        });
-      },
-    };
-  },
-};