@nadicodeai/ui 12.1.165 → 12.1.167

package/dist/eslint/rules/no-hand-built-busy.js

@@ -1,104 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-imports` refuses an import by
- * module, but not the same export by module and file area (PendingLabel is
- * allowed inside packages/ui), and `no-restricted-syntax` cannot join a
- * PendingLabel element to the Button it sits under through a renamed import.
- */
-import { openingElementClassUtilities } from "./jsx-class-utility.js";
-import { PACKAGE_BARREL, renderedImports } from "./rendered-import.js";
-
-const PENDING_LABEL = "PendingLabel";
-const PENDING_LABEL_MODULES = new Set([
-  PACKAGE_BARREL,
-  `${PACKAGE_BARREL}/components/pending-label`,
-]);
-const BUTTONS = new Set(["Button", "ButtonLink"]);
-const SPINNER_ICONS = new Set([
-  "Loader",
-  "LoaderIcon",
-  "Loader2",
-  "Loader2Icon",
-  "LoaderCircle",
-  "LoaderCircleIcon",
-  "LoaderPinwheel",
-]);
-const ICON_MODULE = "lucide-react";
-const SPIN = "animate-spin";
-const FUNCTIONS = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
-
-const PACKAGE_PATH = "/packages/ui/";
-const PORTAL_PATH = "/apps/portal/";
-
-const PENDING_LABEL_ONLY = new Set([PENDING_LABEL]);
-
-const SOURCE_SIDE = { ImportSpecifier: "imported", ExportSpecifier: "local" };
-
-const sourceName = (specifier) => {
-  const named = specifier[SOURCE_SIDE[specifier.type]];
-  return named?.name ?? named?.value;
-};
-
-const isSpinToken = (utility) => utility.split(":").pop().replace(/^!/, "") === SPIN;
-
-function insideAButton(element, importOf) {
-  for (let current = element.parent; current; current = current.parent) {
-    if (FUNCTIONS.has(current.type)) return false;
-    if (current.type === "JSXElement" && BUTTONS.has(importOf(current.openingElement.name)?.name)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-export const noHandBuiltBusy = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A working button takes loading and loadingLabel; no product hand-builds a busy label or a spinner.",
-    },
-    schema: [],
-    messages: {
-      "hand-built-busy":
-        "A working button takes loading and loadingLabel: it keeps its place and focus, says its loadingLabel and shows no spinner. A wait past a second is WaitingLine.",
-    },
-  },
-  create(context) {
-    const filename = context.filename.replaceAll("\\", "/");
-    const inPackage = filename.includes(PACKAGE_PATH);
-    const inPortal = filename.includes(PORTAL_PATH);
-    const importOf = renderedImports(context);
-
-    const report = (node) => context.report({ node, messageId: "hand-built-busy" });
-
-    function bannedFrom(source) {
-      if (source === ICON_MODULE) return SPINNER_ICONS;
-      if (!inPackage && PENDING_LABEL_MODULES.has(source)) return PENDING_LABEL_ONLY;
-      return null;
-    }
-
-    function checkImport(node) {
-      if (node.importKind === "type" || node.exportKind === "type") return;
-      const source = node.source?.value;
-      const bannedNames = bannedFrom(source);
-      if (!bannedNames) return;
-      for (const specifier of node.specifiers) {
-        if (specifier.importKind === "type" || specifier.exportKind === "type") continue;
-        if (bannedNames.has(sourceName(specifier))) report(specifier);
-      }
-    }
-
-    return {
-      ImportDeclaration: checkImport,
-      ExportNamedDeclaration: checkImport,
-      JSXElement(node) {
-        if (importOf(node.openingElement.name)?.name !== PENDING_LABEL) return;
-        if (insideAButton(node, importOf)) report(node.openingElement);
-      },
-      JSXOpeningElement(node) {
-        if (inPortal) return;
-        if (openingElementClassUtilities(node, context).some(isSpinToken)) report(node);
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-hand-built-theme-picker.js

@@ -1,144 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` selector can match a
- * `Sun` element under a `RadioGroup`, but not the same icon named through a
- * renamed import, nor an option table declared in the same file, and it cannot
- * join the icons of two sibling Buttons.
- */
-import { renderedImports, walk } from "./rendered-import.js";
-
-const ICON_MODULE = "lucide-react";
-const PICKERS = new Set(["RadioGroup", "ToggleGroup", "SegmentedControl", "Switch"]);
-const BUTTONS = new Set(["Button", "ButtonLink"]);
-const THEME_ICONS = new Map([
-  ["Sun", "light"],
-  ["SunIcon", "light"],
-  ["Moon", "dark"],
-  ["MoonIcon", "dark"],
-  ["Monitor", "system"],
-  ["MonitorIcon", "system"],
-]);
-const THEME_VALUES = new Set(["light", "dark"]);
-
-const keyName = (property) => property.key.name ?? property.key.value;
-
-function isThemeValue(literal) {
-  const { parent: container } = literal;
-  const parent = container.type === "JSXExpressionContainer" ? container.parent : container;
-  const isItemValue =
-    (parent.type === "JSXAttribute" && parent.name.name === "value") ||
-    (parent.type === "Property" && parent.value === literal && keyName(parent) === "value") ||
-    parent.type === "ArrayExpression" ||
-    parent.type === "CallExpression";
-  return isItemValue && THEME_VALUES.has(literal.value);
-}
-
-const isPropertyName = (identifier) => {
-  const { parent } = identifier;
-  return (
-    (parent.type === "Property" && parent.key === identifier && !parent.computed) ||
-    (parent.type === "MemberExpression" && parent.property === identifier && !parent.computed)
-  );
-};
-
-export const noHandBuiltThemePicker = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "The appearance is chosen with ThemeModeSwitcher or ThemeModeMenu, never a hand-built picker.",
-    },
-    schema: [],
-    messages: {
-      "hand-built-theme-picker":
-        "The appearance is chosen with ThemeModeSwitcher on a settings page or ThemeModeMenu in the account menu; do not rebuild it.",
-    },
-  },
-  create(context) {
-    const { sourceCode } = context;
-    const { visitorKeys } = sourceCode;
-    const importOf = renderedImports(context);
-
-    const iconsByLocalName = new Map();
-    for (const statement of sourceCode.ast.body) {
-      if (statement.type !== "ImportDeclaration" || statement.importKind === "type") continue;
-      if (statement.source.value !== ICON_MODULE) continue;
-      for (const specifier of statement.specifiers) {
-        if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type") continue;
-        const kind = THEME_ICONS.get(specifier.imported.name ?? specifier.imported.value);
-        if (kind) iconsByLocalName.set(specifier.local.name, kind);
-      }
-    }
-
-    const sameFileConstant = (identifier) => {
-      for (let scope = sourceCode.getScope(identifier); scope; scope = scope.upper) {
-        const variable = scope.set.get(identifier.name);
-        if (!variable) continue;
-        const declarator = variable.defs[0]?.node;
-        const isConstant =
-          declarator?.type === "VariableDeclarator" && declarator.parent.kind === "const";
-        return isConstant ? declarator.init : null;
-      }
-      return null;
-    };
-
-    function collect(root, held, followNames) {
-      const visit = (child) => {
-        if (child.type === "JSXOpeningElement") {
-          const imported = importOf(child.name);
-          const kind = imported?.source === ICON_MODULE ? THEME_ICONS.get(imported.name) : null;
-          if (kind) held.icons.add(kind);
-        } else if (child.type === "Identifier" && !isPropertyName(child)) {
-          const kind = iconsByLocalName.get(child.name);
-          if (kind) held.icons.add(kind);
-          else if (followNames) {
-            const init = sameFileConstant(child);
-            if (init) collect(init, held, false);
-          }
-        } else if (child.type === "Literal" && isThemeValue(child)) {
-          held.values.add(child.value);
-        }
-        return true;
-      };
-      visit(root);
-      walk(root, visitorKeys, visit);
-    }
-
-    const holdsAThemeChoice = ({ icons, values }, needsBoth) =>
-      needsBoth ? icons.size >= 2 || values.size === 2 : icons.size >= 1 || values.size === 2;
-
-    const heldBy = (nodes) => {
-      const held = { icons: new Set(), values: new Set() };
-      for (const node of nodes) collect(node, held, true);
-      return held;
-    };
-
-    const buttonsIn = (parent) =>
-      parent.children.flatMap((child) => {
-        if (child.type === "JSXFragment") return buttonsIn(child);
-        const isButton =
-          child.type === "JSXElement" && BUTTONS.has(importOf(child.openingElement.name)?.name);
-        return isButton ? [child] : [];
-      });
-
-    const report = (node) => context.report({ node, messageId: "hand-built-theme-picker" });
-
-    return {
-      JSXElement(node) {
-        if (PICKERS.has(importOf(node.openingElement.name)?.name)) {
-          const held = heldBy([node]);
-          if (holdsAThemeChoice(held, false)) report(node.openingElement);
-          return;
-        }
-        const buttons = buttonsIn(node);
-        if (buttons.length < 2) return;
-        if (holdsAThemeChoice(heldBy(buttons), true)) report(node.openingElement);
-      },
-      JSXFragment(node) {
-        if (node.parent.type === "JSXElement" || node.parent.type === "JSXFragment") return;
-        const buttons = buttonsIn(node);
-        if (buttons.length < 2) return;
-        if (holdsAThemeChoice(heldBy(buttons), true)) report(node);
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-hand-built-tile.js

@@ -1,41 +0,0 @@
-import { findBelow, renderedImports, walk } from "./rendered-import.js";
-
-const FIELD_LABEL = "FieldLabel";
-const FIELD = "Field";
-const CONTROLS = new Set(["RadioGroupItem", "Checkbox"]);
-
-export const noHandBuiltTile = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "A bordered selectable tile is a ChoiceboxGroup, never a FieldLabel around a Field with a radio or a checkbox.",
-    },
-    schema: [],
-    messages: {
-      "hand-built-tile":
-        "A bordered selectable tile is a ChoiceboxGroup with ChoiceboxGroupItem. Options without a description are a plain RadioGroup with a Label for each.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const { visitorKeys } = context.sourceCode;
-    const isRendered = (name) => (node) =>
-      node.type === "JSXElement" && name(importOf(node.openingElement.name)?.name);
-    const isField = isRendered((name) => name === FIELD);
-    const isControl = isRendered((name) => CONTROLS.has(name));
-
-    return {
-      JSXElement(node) {
-        if (importOf(node.openingElement.name)?.name !== FIELD_LABEL) return;
-        let handBuilt = false;
-        walk(node, visitorKeys, (child) => {
-          if (!isField(child) || !findBelow(child, visitorKeys, isControl)) return true;
-          handBuilt = true;
-          return "stop";
-        });
-        if (handBuilt) context.report({ node: node.openingElement, messageId: "hand-built-tile" });
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-hand-formatted-date.js

@@ -1,87 +0,0 @@
-/*
- * Standard tool checked first: `no-restricted-syntax` can match a member named
- * `toLocaleDateString` or `new Intl.DateTimeFormat`, but `toLocaleString` is
- * also how a number is written, so it is a date only when its options object
- * names a date or time part, which a selector cannot read. It reports only a
- * date written into markup (inside a JSX expression of the same function): a
- * helper that returns a chart label, a period name or an email's text has no
- * element to put a RecordTime in.
- */
-const ALWAYS_DATES = new Set(["toLocaleDateString", "toLocaleTimeString"]);
-const DATE_PARTS = new Set([
-  "dateStyle",
-  "timeStyle",
-  "weekday",
-  "era",
-  "year",
-  "month",
-  "day",
-  "dayPeriod",
-  "hour",
-  "minute",
-  "second",
-  "fractionalSecondDigits",
-  "timeZoneName",
-  "hour12",
-  "hourCycle",
-]);
-
-const isIntlDateTimeFormat = (callee) =>
-  callee.type === "MemberExpression" &&
-  !callee.computed &&
-  callee.object.type === "Identifier" &&
-  callee.object.name === "Intl" &&
-  callee.property.name === "DateTimeFormat";
-
-const namesADatePart = (options) =>
-  options?.type === "ObjectExpression" &&
-  options.properties.some(
-    (property) =>
-      property.type === "Property" &&
-      !property.computed &&
-      property.key.type === "Identifier" &&
-      DATE_PARTS.has(property.key.name),
-  );
-
-const FUNCTIONS = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
-
-function writtenIntoMarkup(node) {
-  for (let current = node.parent; current; current = current.parent) {
-    if (current.type === "JSXExpressionContainer") return true;
-    if (FUNCTIONS.has(current.type)) return false;
-  }
-  return false;
-}
-
-export const noHandFormattedDate = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "An app shows a moment through RecordTime, never a hand-formatted date.",
-    },
-    schema: [],
-    messages: {
-      "hand-formatted-date":
-        "Show a moment with RecordTime from @nadicodeai/ui/components/record-time: it reads relative within a week, then the date, in the viewer's zone and language, with the exact time in a card. A date formatted by hand drifts from the other screens and shows the server's zone.",
-    },
-  },
-  create(context) {
-    function check(node) {
-      if (!writtenIntoMarkup(node)) return;
-      const { callee } = node;
-      if (isIntlDateTimeFormat(callee)) {
-        context.report({ node, messageId: "hand-formatted-date" });
-        return;
-      }
-      if (callee.type !== "MemberExpression" || callee.computed) return;
-      const name = callee.property.name;
-      if (
-        ALWAYS_DATES.has(name) ||
-        (name === "toLocaleString" && namesADatePart(node.arguments[1]))
-      ) {
-        context.report({ node, messageId: "hand-formatted-date" });
-      }
-    }
-    return { CallExpression: check, NewExpression: check };
-  },
-};

package/dist/eslint/rules/no-hand-stacked-avatars.js

@@ -1,67 +0,0 @@
-import { openingElementClassUtilities } from "./jsx-class-utility.js";
-import { renderedImports } from "./rendered-import.js";
-
-const AVATAR = "Avatar";
-const OVERLAP = /^-(?:space-x-|ml-|ms-|mx-)/;
-
-const hasOverlapClass = (node, context) =>
-  openingElementClassUtilities(node, context).some((utility) =>
-    OVERLAP.test(utility.slice(utility.lastIndexOf(":") + 1).replace(/^!|!$/g, "")),
-  );
-
-function returnedElement(callback) {
-  if (callback?.type !== "ArrowFunctionExpression" && callback?.type !== "FunctionExpression") {
-    return null;
-  }
-  if (callback.body.type !== "BlockStatement") return callback.body;
-  return callback.body.body.find((statement) => statement.type === "ReturnStatement")?.argument;
-}
-
-export const noHandStackedAvatars = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Stacked avatars are one AvatarGroup, never sibling Avatars or an overlap written on a parent or an Avatar.",
-    },
-    schema: [],
-    messages: {
-      "hand-stacked-avatars":
-        "Stacked avatars are one <AvatarGroup members={...} label={...} />, which owns the overlap, the order, the +N count and the group's label.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const reported = new WeakSet();
-    const isAvatar = (node) =>
-      node?.type === "JSXElement" && importOf(node.openingElement.name)?.name === AVATAR;
-
-    function report(avatar) {
-      if (reported.has(avatar)) return;
-      reported.add(avatar);
-      context.report({ node: avatar.openingElement, messageId: "hand-stacked-avatars" });
-    }
-
-    return {
-      JSXElement(node) {
-        if (isAvatar(node) && hasOverlapClass(node.openingElement, context)) report(node);
-        const avatars = node.children.filter(isAvatar);
-        if (avatars.length >= 2) report(avatars[1]);
-      },
-      JSXFragment(node) {
-        const avatars = node.children.filter(isAvatar);
-        if (avatars.length >= 2) report(avatars[1]);
-      },
-      CallExpression(node) {
-        const { callee, parent } = node;
-        const isMap =
-          callee.type === "MemberExpression" && !callee.computed && callee.property.name === "map";
-        if (!isMap) return;
-        if (parent.type !== "JSXExpressionContainer" || parent.parent.type !== "JSXElement") return;
-        if (!hasOverlapClass(parent.parent.openingElement, context)) return;
-        const returned = returnedElement(node.arguments[0]);
-        if (isAvatar(returned)) report(returned);
-      },
-    };
-  },
-};

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

@@ -1,60 +0,0 @@
-/*
- * Standard tool checked first: a `no-restricted-syntax` descendant selector
- * matches by element name, so it cannot tell the package's Accordion from a
- * local component of the same name, a renamed import, or a Disclosure's
- * `label` (which is not its content) from its children.
- */
-import { packageModules, partOf, renderedImports } from "./rendered-import.js";
-
-const PARTS = [
-  ["accordion", "Accordion"],
-  ["accordion", "AccordionContent"],
-  ["collapsible", "Collapsible"],
-  ["collapsible", "CollapsibleContent"],
-  ["disclosure", "Disclosure"],
-];
-
-const PART_EXPORTERS = new Map(
-  PARTS.map(([module, part]) => [
-    part,
-    [...packageModules(module), `@/components/${module}`].map((from) => ({ from, part })),
-  ]),
-);
-
-const COLLAPSES = new Set(["Accordion", "Collapsible", "Disclosure"]);
-const COLLAPSED_CONTENT = new Set(["AccordionContent", "CollapsibleContent", "Disclosure"]);
-
-export const noNestedCollapse = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "An Accordion, Collapsible or Disclosure never sits in another's content.",
-    },
-    schema: [],
-    messages: {
-      "nested-collapse":
-        "A collapse never sits in another: two levels hide too much and break the keyboard path. Make the inner one a section of the page, or flatten the outer.",
-    },
-  },
-  create(context) {
-    const importOf = renderedImports(context);
-    const partRendered = (element) =>
-      partOf(importOf(element.openingElement.name), PART_EXPORTERS, context.filename);
-
-    return {
-      JSXElement(node) {
-        if (!COLLAPSES.has(partRendered(node))) return;
-        let child = node;
-        for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
-          const holdsAsContent =
-            ancestor.type === "JSXElement" && ancestor.children.includes(child);
-          if (holdsAsContent && COLLAPSED_CONTENT.has(partRendered(ancestor))) {
-            context.report({ node, messageId: "nested-collapse" });
-            return;
-          }
-          child = ancestor;
-        }
-      },
-    };
-  },
-};

package/dist/eslint/rules/no-package-component-redefinition.js

@@ -1,175 +0,0 @@
-/*
- * A route does not re-declare a component the package already ships.
- *
- * `@nadicodeai/ui` is the website's component surface. A route that declares
- * its own `Footer`, `Card` or `Badge` forks a shipped component into a page,
- * where the package's next change does not reach it — and the two are then
- * told apart only by their import paths.
- *
- * The names are DERIVED from the package's build surface at lint time: the
- * `types` target of its `exports` map, followed through the barrel's
- * `export *` chain. There is no list here to keep in step with the package;
- * a component added or removed by the package changes this rule's answer with
- * no edit at all.
- *
- * Standard tool checked first: core `no-redeclare` and
- * `no-shadow` answer only inside one scope chain, and `no-restricted-syntax`
- * would need every name spelled into a selector — the hand list this derivation
- * exists to avoid. Deferred here from #819 for exactly that reason.
- */
-import { existsSync, readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const PACKAGE = "@nadicodeai/ui";
-
-/*
- * TypeScript is loaded when this rule first runs, not when the plugin loads.
- * The plugin's bytes are published inside `@nadicodeai/ui`, which does not
- * depend on the compiler; a consumer who never enables this rule never asks
- * for it, and one who does is already linting TypeScript.
- */
-let ts;
-function typescript() {
-  ts ??= createRequire(import.meta.url)("typescript");
-  return ts;
-}
-
-/** The `.d.ts` the package's `exports` map names as its root type surface. */
-function typeSurfaceEntry() {
-  let directory = dirname(fileURLToPath(import.meta.resolve(PACKAGE)));
-  for (;;) {
-    const manifestPath = join(directory, "package.json");
-    let manifest;
-    try {
-      manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-    } catch {
-      const parent = dirname(directory);
-      if (parent === directory) {
-        throw new Error(`${PACKAGE}: no manifest above its resolved entry point`);
-      }
-      directory = parent;
-      continue;
-    }
-    if (manifest.name !== PACKAGE) {
-      throw new Error(`${manifestPath} is not ${PACKAGE}`);
-    }
-    const entry = join(directory, manifest.exports["."].types);
-    if (!existsSync(entry)) {
-      throw new Error(
-        `${PACKAGE} has no built type surface at ${entry}: build the package before linting.`,
-      );
-    }
-    return entry;
-  }
-}
-
-/*
- * A type is not a component. `export type ChartConfig` names a shape a route
- * may legitimately declare its own version of, and it cannot be imported as a
- * component at all, so the derived set holds values only: type aliases,
- * interfaces, and the `type` marker on an export clause are dropped.
- */
-function isTypeOnlyStatement(ts, statement) {
-  return (
-    ts.isTypeAliasDeclaration(statement) ||
-    ts.isInterfaceDeclaration(statement) ||
-    statement.isTypeOnly === true
-  );
-}
-
-function exportedNames(file, names = new Set(), seen = new Set()) {
-  if (seen.has(file)) return names;
-  seen.add(file);
-  const ts = typescript();
-  const source = ts.createSourceFile(
-    file,
-    readFileSync(file, "utf8"),
-    ts.ScriptTarget.Latest,
-    false,
-    ts.ScriptKind.TS,
-  );
-  for (const statement of source.statements) {
-    if (ts.isExportDeclaration(statement)) {
-      if (statement.moduleSpecifier && !statement.exportClause) {
-        exportedNames(
-          join(dirname(file), statement.moduleSpecifier.text.replace(/\.js$/, ".d.ts")),
-          names,
-          seen,
-        );
-      } else if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
-        if (isTypeOnlyStatement(ts, statement)) continue;
-        for (const element of statement.exportClause.elements) {
-          if (element.isTypeOnly) continue;
-          names.add(element.name.text);
-        }
-      }
-      continue;
-    }
-    const modifiers = ts.canHaveModifiers(statement) ? (ts.getModifiers(statement) ?? []) : [];
-    if (!modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) continue;
-    if (isTypeOnlyStatement(ts, statement)) continue;
-    if (ts.isVariableStatement(statement)) {
-      for (const declaration of statement.declarationList.declarations) {
-        if (ts.isIdentifier(declaration.name)) names.add(declaration.name.text);
-      }
-    } else if (statement.name && ts.isIdentifier(statement.name)) {
-      names.add(statement.name.text);
-    }
-  }
-  return names;
-}
-
-let packageExports;
-
-/** Read once per lint process; the built surface does not move under it. */
-function packageExportNames() {
-  packageExports ??= exportedNames(typeSurfaceEntry());
-  return packageExports;
-}
-
-const COMPONENT_NAME = /^[A-Z]/;
-
-function isFunctionLike(node) {
-  return (
-    node?.type === "ArrowFunctionExpression" ||
-    node?.type === "FunctionExpression" ||
-    node?.type === "ClassExpression" ||
-    node?.type === "CallExpression"
-  );
-}
-
-export const noPackageComponentRedefinition = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: `Disallow declaring a component whose name ${PACKAGE} already exports`,
-    },
-    schema: [],
-    messages: {
-      redefined: `{{name}} is exported by ${PACKAGE}: import it instead of declaring a second one here.`,
-    },
-  },
-  create(context) {
-    const report = (node, name) => {
-      if (!COMPONENT_NAME.test(name) || !packageExportNames().has(name)) return;
-      context.report({ node, messageId: "redefined", data: { name } });
-    };
-
-    return {
-      FunctionDeclaration(node) {
-        if (node.id) report(node.id, node.id.name);
-      },
-      // A class is the third way to write a component; React still renders one.
-      ClassDeclaration(node) {
-        if (node.id) report(node.id, node.id.name);
-      },
-      VariableDeclarator(node) {
-        if (node.id.type === "Identifier" && isFunctionLike(node.init)) {
-          report(node.id, node.id.name);
-        }
-      },
-    };
-  },
-};